Does the scaffolding around an AI model — how work is split up and organized — matter as much as the model itself?
How much does workflow architecture matter versus raw model capability?
This explores whether the structure built around a model (how tasks are split up, which tools it calls, how information is organized for it) changes results as much as making the model itself stronger.
This explores whether the structure built around a model matters as much as the model's raw strength. The corpus leans toward architecture mattering more than most people expect, but it never treats the two as interchangeable. The more interesting finding is that they interact, and a stronger model doesn't always get more out of good structure.
The strongest evidence for architecture comes from cases where structure lets a weaker model punch above its weight. Reorganizing a code repository around runtime behavior, so the planner gets an explicit map from behaviors to code, raised win rates by 10-19 points and cut planner tokens. Weaker planners using the map matched stronger models at finding the right code Can explicit behavior maps help weaker planners compete with stronger models?. Splitting a reasoning task into a separate decomposer and a separate solver beat a single monolithic model, and the decomposing skill transferred across domains while the solving skill didn't Does separating planning from execution improve reasoning accuracy?. The same pattern shows up outside LLMs. In recommender systems, removing hidden layers and adding constraints beat deeper, higher-capacity models What architectural choices actually improve recommender system performance?.
In production, architecture often decides whether the system works at all. One team replaced protocol-mediated tool access with explicit function calls, one tool per agent, and the non-deterministic failures went away. A survey of 306 practitioners found 85% of production teams build custom agents rather than use frameworks Why do protocol-based tool integrations fail in production workflows?. Turning an LLM into an agent takes a whole pipeline (action datasets, grounding, memory and tools, safety evaluation), and retraining alone doesn't get there Can you turn an LLM into an agent by just fine-tuning?. Some domains resist automated research whatever model you point at them. If a domain lacks fast scalar metrics, modularity, quick iteration and version control, the bottleneck is the environment, not model power What makes a research domain suitable for autonomous optimization?. Architecture also decides what a model can touch. FlowMind has the LLM compose calls to vetted APIs and never see proprietary data Can LLMs generate workflows without touching proprietary data?.
The surprise is that scaffolding and capability don't sit on one dial. When models were asked to improve their own harnesses, the ability to write useful edits stayed flat across tiers. The ability to benefit from those edits peaked in mid-tier models, because weak models fail to invoke the harness and strong models struggle to follow its instructions faithfully Do stronger models always evolve harnesses better?. So the best model isn't automatically the best fit for a given workflow design.
Capability also changes what architecture has to guard against. Weaker models degrade documents by visibly deleting content, while frontier models corrupt it silently and keep the surface looking intact Does model capability change how documents degrade?. Short benchmarks don't predict how models behave across 50-round workflows, and models that rank similarly early diverge sharply by relay 25 Do short benchmarks predict how models perform over long workflows?. Even the capability number is shaky, since a model can score perfectly while its internal organization is fractured in ways standard evaluation can't see Can models be smart without organized internal structure?. Some fixes are cheap and structural: a penalty on switching thoughts at decoding time helps reasoning models that abandon promising paths too early, with no fine-tuning Why do reasoning models abandon promising solution paths?. The corpus doesn't give a ratio. Its answer is that the design around the model decides whether capability gets used, and that stronger models need different checks, not fewer of them.
Sources 12 notes
A behavior-to-code mapping representation improved win rates by 10–19 points while reducing planner tokens by 8–13%. Weaker planners using this mapping matched stronger models' code localization across all precision and recall metrics.
Modular architectures with separate decomposer and solver models outperform monolithic LLMs, with decomposition ability transferring across domains while solving ability does not. The separation prevents planning-execution interference and produces more generalizable skills.
Research shows that architectural choices like removing hidden layers, enforcing constraints on self-similarity, and using appropriate likelihood functions deliver better results than deeper or more complex models. This suggests that problem-specific design decisions matter more than raw representational capacity.
MCP integration caused non-deterministic failures through ambiguous tool selection and parameter inference. Replacing it with explicit direct function calls and single-tool-per-agent design restored determinism. A 306-practitioner survey confirms 85% of production teams build custom agents, forgoing frameworks.
Converting LLMs to action-capable systems requires four distinct stages: curating action-environment-user datasets, training for action grounding, integrating agent infrastructure with memory and tools, and rigorous safety evaluation. The surrounding system and harness determine whether actions are grounded or hallucinated.
Show all 12 sources
Autonomous research pipelines require immediate scalar metrics, modular architecture, fast iteration cycles, and version control. Domains lacking any property resist autoresearch regardless of LLM capability, because the bottleneck is environmental structure, not model power.
FlowMind demonstrates that LLMs can generate on-the-fly workflows for spontaneous tasks by orchestrating calls to vetted APIs rather than accessing data directly, eliminating confidentiality risks while maintaining high-level human inspection and feedback.
Model capability to produce useful harness edits stays constant across tiers, but capacity to actually benefit from those edits follows an inverted U-shape, peaking in mid-tier models. Weak models fail to invoke harnesses; strong models struggle with faithful instruction-following.
DELEGATE-52 shows weaker LLMs degrade documents through visible deletion, while frontier models degrade through subtle corruption that preserves surface integrity. This shift makes frontier failures harder to detect and potentially more dangerous at workflow scale.
DELEGATE-52 evaluated models across 50-round-trip relays and found short-interaction performance does not predict sustained delegation accuracy. Models ranking similarly on single-turn tasks diverged dramatically by relay 25, revealing degradation curves invisible to standard benchmarks.
Models trained with SGD can contain all the linearly decodable features needed for a task while maintaining fundamentally broken internal organization. This makes them vulnerable to perturbation and distribution shift invisible to standard evaluation metrics.
Reasoning LLMs exhibit two reinforcing failures: wandering (invalid exploration) and underthinking (premature path-switching). Decoding-level interventions like thought-switching penalties improve accuracy without fine-tuning, suggesting viable solutions exist but are abandoned prematurely.
Papers this line draws on 8
The research behind the notes this line reads — ranked by how closely each paper relates.
- Harness Updating Is Not Harness Benefit: Disentangling Evolution Capabilities in Self-Evolving LLM Agents
- Large Language Model Reasoning Failures
- LLMs Corrupt Your Documents When You Delegate
- RRSI: Regularized Recursive Self-Improvement of Agent Harnesses
- Harness Handbook: Making Evolving Agent Harnesses Readable,Navigable, and Editable
- Reasoning LLMs are Wandering Solution Explorers
- Large Language Models Think Too Fast To Explore Effectively
- Rethinking the Evaluation of Harness Evolution for Agents