The prevailing wisdom in local LLM deployment suggests that scaling up model size solves reliability issues. Part 6 of Sven Welack’s series on running LLMs on consumer hardware shatters that assumption. After resolving memory bottlenecks by moving workers to a secondary machine, the team deployed a 77 GB coordinator model, expecting it to handle complex orchestration tasks with greater fidelity. Instead, the larger model exhibited the same structural failures as its smaller predecessors, proving that raw parameter count cannot compensate for architectural flaws in agentic loops.

The Illusion of Scale

With memory constraints lifted, the 77 GB coordinator was tested against the same long-horizon planning tasks that had previously stumped smaller models like Gemma. While it sequenced delegations slightly more reliably, it failed to escape the core failure modes of agentic orchestration. The model continued to drop steps from multi-part plans, silently omitting necessary delegations before generating summaries. More critically, it occasionally emitted delegation commands as raw text or JSON rather than executing them, a behavior previously observed in smaller models. The system also suffered from 'empty turns,' where the model would return no output after a tool call, requiring automatic nudges to resume operation.

Diagnosing the Structural Flaw

The recurrence of these errors across vastly different model sizes points to a fundamental mismatch between language model architecture and the demands of stateful orchestration. An LLM asked to act as a coordinator must simultaneously function as a planner, dispatcher, bookkeeper, and evaluator. This requires maintaining a complex state machine across numerous interaction turns, a task for which transformer architectures are poorly suited. A larger model may raise the performance ceiling marginally, but it does not remove the structural bottleneck. The model is not 'forgetting' steps; it is being asked to perform deterministic state management using a probabilistic reasoning engine.

The Deterministic Fix

The solution was not to find a smarter model, but to strip the model of its most incoherent responsibilities. The team implemented deterministic orchestration, where a simple script manages the control loop. This script holds the task list, dispatches delegations, collects results, and determines the next step. The LLM is invoked only for two specific tasks where it excels: initial planning and final evaluation. By offloading the bookkeeping to code, the system eliminated the 'nudge' loops and dropped steps. A test sequence that previously stalled at three of five steps completed all five when managed by the script, despite using the same underlying model.

Key Takeaways

  • Model size does not fix agentic loop instability; architecture does.
  • LLMs are poor at maintaining state across long control loops.
  • Deterministic scripts should handle dispatching and bookkeeping.
  • Reserve LLMs for high-judgment tasks: planning and evaluation.

The Bottom Line

Stop trying to brute-force agentic reliability with bigger weights. The loop is a program’s job, not a language model’s.