Why do production AI agents deliberately stay simple and avoid frameworks?
This explores why teams shipping real AI agents tend to hand-build narrow, few-step systems instead of adopting big orchestration frameworks — and what that choice buys them.
This explores why teams shipping real AI agents tend to hand-build narrow, few-step systems instead of adopting big orchestration frameworks. The blunt answer from practice: simplicity is what makes them reliable enough to deploy. A survey of 306 practitioners across 26 domains found that 68% of production agents execute at most 10 steps, 85% build custom systems rather than lean on frameworks, and 74% keep a human in the evaluation loop Why do production AI agents stay deliberately simple?. Constraint isn't a limitation they tolerate — it's the design choice that works.
Why does autonomy degrade so fast? Because capability is rarely the bottleneck. Even leading agents complete only about 30% of realistic workplace tasks, with failure concentrating in social interaction, UI navigation, and domain-specific knowledge — and multi-turn performance sagging to ~35% Why do AI agents fail at workplace social interaction?. Every additional step is another chance to compound an error, so capping the number of steps is a direct purchase of predictability. A longer, framework-driven plan multiplies exactly the points where things go wrong.
The deeper reason frameworks underdeliver is that reliability doesn't live in clever orchestration — it lives in giving the agent solid external structure. Reliable agents externalize three burdens into a 'harness' layer: memory (state that persists), skills (reusable procedures), and protocols (structured interaction), so the model isn't re-solving the same problems every run Where does agent reliability actually come from?. Generic frameworks abstract these away behind their own conventions; a custom-built harness lets a team shape memory and protocols to their actual task. Relatedly, when agents use code as their working medium — executable, inspectable, stateful — they get verification and progress-checking almost for free, which a flexible loop captures better than a rigid framework graph Can code become the operational substrate for agent reasoning?.
There's also an economic and architectural logic to staying lean. Most agent subtasks are repetitive, well-defined language operations that small models handle at 10–30× lower cost, making 'small by default, large only when needed' the rational pattern Can small language models handle most agent tasks?. And where speed matters, calling APIs directly instead of driving sequential UI steps cuts task time 65–70% while holding accuracy near 98% Can API-first agents outperform UI-based agent interaction? — again, fewer moving parts, more reliability. Frameworks tend to push you toward heavyweight, uniform pipelines that fight both of these wins.
The interesting counter-current: simplicity is right for *today's* deployments, not a permanent law. As agents start holding credentials, moving money, and interacting with other agents, the binding constraint shifts from raw capability to coordination, settlement, and auditability When do agents need coordination more than raw capability? — and there's early work on meta-agents that generate a bespoke multi-agent structure per query rather than using fixed templates Can AI systems design unique multi-agent workflows per individual query?. So the lesson isn't 'never add structure.' It's that structure should be earned by the task and externalized into a harness you control — not inherited wholesale from a framework before your agent has proven it can reliably take ten steps.
Sources 8 notes
A survey of 306 practitioners across 26 domains shows 68% of deployed agents execute at most 10 steps, 85% build custom systems rather than use frameworks, and 74% rely on human evaluation. Simplicity and human oversight, not complexity, drive production success.
TheAgentCompany benchmark shows leading agents achieve 30% task completion in a simulated workplace. Social interaction, professional UI navigation, and domain-specific knowledge are the three primary failure modes, with multi-turn task performance consistently dropping to 35% across enterprise settings.
Research shows reliable LLM agents externalize three cognitive burdens—memory (state persistence), skills (procedural components), and protocols (structured interaction)—into a harness layer rather than relying on model scale alone. The harness unifies these externalities and eliminates the need for the model to solve the same problems repeatedly.
Research shows code uniquely enables agents to externalize reasoning, execute policies, model environments, and verify progress through its simultaneous executability, inspectability, and statefulness across task steps.
SLMs handle the repetitive, well-defined language tasks that constitute most agent work at 10–30× lower cost than LLMs, making heterogeneous architectures (SLMs by default, LLMs selective) the economically rational design pattern.
The AXIS framework shows that prioritizing API calls over sequential UI interactions cuts task completion time by 65–70% while maintaining 97–98% accuracy and reducing cognitive workload by 38–53%. A self-exploration mechanism automatically discovers and constructs APIs from existing applications, solving the bootstrapping problem.
Once agents hold credentials, transact value, and interact with other agents, raw model capability stops being the limiting factor. The real bottleneck becomes whether agents can coordinate reliably, settle accounts, and leave auditable evidence of their actions.
FlowReasoner demonstrates that meta-agents trained with reinforcement learning and external execution feedback can generate unique multi-agent architectures for each user query, optimizing across performance, complexity, and efficiency—moving beyond fixed task-level workflow templates.