Architecture Beats Scale: Why Agent Trees Outperform Bigger Models

For the past two years, the dominant narrative in AI has been a simple one: bigger models are better models. If your agent fails on a complex task, the answer must be a larger parameter count, more training data, or a more expensive inference tier.

A paper presented this week at AAMAS 2026 suggests that narrative is incomplete — and for production agent deployments, potentially misleading.

ETRI’s ReAcTree introduces hierarchical agent trees for long-horizon task planning. The headline result is straightforward: using Qwen 2.5 72B, ReAcTree achieves a 61% goal success rate on the WAH-NL benchmark — nearly double the 31% achieved by the standard ReAct method with the same model.

But that is not the most interesting number in the paper.

The most interesting number is that when ReAcTree is paired with a 7B parameter model, it still reaches 37% success rate — outperforming the 72B model running flat ReAct (31%). A model with one-tenth the parameters, guided by the right architecture, beats a model ten times its size operating in the standard configuration.

This is not a marginal improvement. It is a structural insight about where agent reliability actually comes from.

The Flat Chain Problem

The ReAct method — reason, act, observe, repeat — has been the default architecture for LLM-based agents since Yao et al. 2022. It is simple, effective for short tasks, and widely deployed. But it has a fundamental limitation: the entire task history is processed as a single, growing context window.

For a two-step task like “turn on the light,” this works fine. For a ten-step task like “cook potato slices and put them in the refrigerator,” the flat approach degrades in predictable ways. The model forgets earlier context. It skips intermediate steps. It hallucinates actions that were never completed. Each new observation pushes older context out of the model’s effective attention span, and errors compound as the trajectory lengthens.

This is not a model quality problem. It is an architectural problem. No amount of parameter scaling can fully compensate for a serial context bottleneck — every model, regardless of size, has a finite window and a tendency to lose the thread in long procedural sequences.

How ReAcTree Works

ReAcTree replaces the flat trajectory with a hierarchical agent tree structured like a corporate org chart.

At the top, a manager agent receives the overall goal and decomposes it into subgoals. Each subgoal is assigned to a dedicated child agent node. Those child nodes can further split their own subgoals, creating a tree of specialized agents working in parallel or sequence. Control flow nodes coordinate execution — deciding when to run agents concurrently, when to sequence them, and how to merge their results.

The architecture draws on two memory systems:

• Episodic memory stores past successful subgoal-level examples. When a manager encounters a task similar to one it has solved before, it retrieves the relevant plan structure rather than reasoning from scratch each time.

• Working memory shares environment state across all agent nodes instantly. If one agent discovers “there is juice in the refrigerator,” every agent knows it without needing to re-observe or re-query.

This dual-memory design is what prevents the context loss that plagues flat approaches. Each subgoal agent operates in a focused context window — it only needs to track its own small piece of the task. The manager handles the big picture. Working memory provides real-time shared state. Episodic memory provides reusable patterns.

The 7B vs 72B Result

The benchmark results break down like this on WAH-NL:

Method	Model	Success Rate
ReAct (flat)	72B	31%
ReAcTree (hierarchical)	72B	61%
ReAcTree (hierarchical)	7B	37%

The 72B ReAct agent fails on 69% of tasks. A 7B model with the right architecture outperforms it.

This has immediate practical implications. If you are building a production agent system today, the conventional wisdom says to budget for the largest model you can afford. ReAcTree suggests a different optimization: invest in architecture first, then scale the model to meet remaining gaps.

A 7B model running ReAcTree costs roughly one-tenth the inference budget of a 72B model running ReAct, and it completes tasks more reliably. For high-volume systems — customer support triage, data pipeline orchestration, automated testing — this is the difference between a viable product and one that burns margin on inference.

Why This Matters for Production Agents

The agent reliability problem has been the single biggest barrier to production deployment. Every team building agents encounters the same frustration: the demo works, but the production system falls apart on the third edge case in a multi-step workflow.

The dominant response has been to reach for larger models. If GPT-4 fails, try GPT-4.5. If Claude 3.5 Sonnet drops context, switch to Opus. This creates an expensive arms race where reliability improvements are bought at increasingly high inference cost.

ReAcTree demonstrates a different lever: better orchestration of smaller models outperforms naive orchestration of larger ones. The architectural insight generalizes beyond household task planning:

• Multi-step tool use: A flat agent that calls API after API will eventually lose track of which calls succeeded and which failed. Hierarchical decomposition — a parent agent that dispatches API calls to child agents and reconciles their results — keeps each call’s context isolated.

• Long-running workflows: Agents that run for hours (monitoring, data reconciliation, code generation) inevitably accumulate enough context to trigger hallucinations. A tree structure with checkpointing between subgoals prevents cumulative drift.

• Error recovery: When a flat agent fails at step 7, the entire task restarts. When a tree agent fails at a subgoal, only that subtree needs to retry — the manager retains the rest of the plan.

The Next Frontier: Agents That Ask for Help

The ReAcTree paper mentions a planned feature that may be as significant as the architecture itself: adding the ability for agent nodes to resolve uncertainty by asking human questions.

Current agent architectures treat uncertainty as a failure mode to be hidden or guessed through. An agent that cannot find the kitchen knife hallucinates finding it. An agent that is unsure which account to charge guesses. This guessing behavior is what makes autonomous agents dangerous in production — they act on incorrect assumptions rather than escalating to a human who can disambiguate.

The ReAcTree team plans to add a clarification mechanism where agents can pause and ask for human input when confidence drops below a threshold. This is the right direction. The most reliable production agents will not be the ones that guess best — they will be the ones that know when to stop guessing and ask for help.

What This Means

The agent industry is still young, and the default architectures are inherited from a time when LLMs were used for single-turn text generation. ReAcTree is part of a growing body of evidence that the next leap in agent capability will come not from model scale, but from agent architecture — how we structure reasoning, memory, delegation, and error recovery across multiple model instances.

If a 7B model with hierarchical trees beats a 72B model with flat prompting, imagine what a 72B model with hierarchical trees will achieve when the architecture is applied at scale.

The lesson for anyone building agents today: before you upgrade to a larger model, fix your architecture first. The model is not the bottleneck.