RS4 Lab’s October 2026 release of experimental data offers a brutal reality check for developers building AI pipelines: if you aren’t measuring every millisecond, you’re guessing. Over a three-week sprint from September 12 to October 3, the team instrumented three distinct systems—SofiaVoice, Cortex-Flow, and a Commerce Pipeline—to test the hypothesis that deterministic code should handle everything except judgment. The results, published in detailed JSON metrics and Markdown reports, reveal that blind optimization often targets the wrong bottleneck, and that local hardware constraints are far more immediate than model capability limits.

The Latency Lie: TTS Was the Real Bottleneck

In Experiment 005, the team rebuilt SofiaVoice, a synchronous voice assistant, after discovering that the Large Language Model (LLM) was actually the fastest component. The v1 baseline showed a total latency of 5.806 seconds per turn, but a breakdown revealed that Text-to-Speech (TTS) using gTTS consumed 4.415 seconds, or 76.1% of the total time. The LLM stage (LLaMA 3.3) took only 0.673 seconds. By swapping the TTS engine to Edge-TTS Neural and moving to an async FastAPI architecture, they reduced end-to-end latency to 2.800 seconds, a 51.7% improvement. The key takeaway for builders: don’t optimize the model if your audio synthesis is dragging you down.

Hardware Ceilings Hit Local LLM Agents Hard

Experiment 006 moved to Cortex-Flow v2, a typed state graph running on a CPU-only Windows 11 workstation via Ollama. The data exposes a harsh performance ceiling: every 7B model node decoded at approximately 6 tokens per second. Route B, which included a Builder node, took 33.9 minutes to complete, with the Builder alone consuming 599.9 seconds. The team noted that nodes ran 1.9–2.7× slower during full integration tests compared to isolated unit tests due to growing shared state and prompt pre-fill costs. This confirms that for local agent frameworks, reducing output token count is a more effective optimization lever than trying to squeeze more speed out of the same 7B model.

Deterministic Routing Saves Critical Compute

To avoid burning minutes on simple decisions, RS4 implemented a deterministic keyword router for triage. Instead of using an LLM to decide whether a task was a copywriting job or a coding job, they used keyword scoring. The data shows this triage step took just 0.17 to 0.33 milliseconds. In contrast, any LLM call on their hardware costs between 30 seconds and 5 minutes. By keeping routing deterministic, they saved massive amounts of compute time for the actual judgment tasks. The system also enforced a strict 'human-in-the-loop' protocol; in both test routes, the final status was PENDENTE_HUMANO, meaning the AI recommended a path but refused to close the loop without human approval.

The Zero-Cost Constraint Forces Simplicity

All experiments operated under a R$ 0.00 constraint, using local models and standard libraries. The Commerce Pipeline (EXP007) was built as a deterministic, LLM-free feeder that exported clean, typed JSON payloads to Cortex-Flow. It processed 16–17 items daily in under 9 seconds with zero exceptions. The lab’s philosophy document was embedded directly into the system’s vector memory, ensuring that agents judged outputs against specific RS4 criteria like 'radical simplicity' and 'LGPD compliance' rather than generic quality metrics. This approach turns philosophical principles into executable code, forcing the system to reject its own outputs if they violate core rules, as seen when the Evaluator scored a generated ad 3/5 and flagged missing evidence.

Key Takeaways

  • Measure before you optimize: TTS caused 76% of latency in SofiaVoice, not the LLM.
  • Local 7B models hit a hard ceiling of ~6 tokens/sec on CPU; reduce output length, not just model size.
  • Deterministic keyword routing is thousands of times faster than LLM-based routing.
  • Embed your philosophy into vector memory to create enforceable quality gates.
  • Always keep a human in the loop for final decisions; AI should recommend, not close.

The Bottom Line

Stop throwing bigger models at slow pipelines. The data proves that architectural discipline, deterministic routing, and rigorous measurement deliver more performance gains than model upgrades alone.