Here is a result that should make everyone in AI rethink what “bigger is better” means. Researchers at South Korea’s Electronics and Telecommunications Research Institute (ETRI) built a system called ReAcTree that organizes AI agents the way companies organize people — a top-level manager breaking goals into subgoals for specialized sub-agents. Tested against the standard ReAct approach, ReAcTree nearly doubled task success rates. And most strikingly: a small 7-billion-parameter model running ReAcTree outperformed a 72-billion-parameter model running the conventional method.
The work was presented at AAMAS 2026, one of the premier conferences in the AI agent field, and reported in July. It is a planning breakthrough, not a model breakthrough — and that distinction is exactly why it matters.
The problem with long tasks
Large language models are fluent and knowledgeable, but they are unreliable at long-horizon tasks — anything where many steps must proceed in sequence, like cooking a meal, cleaning a house, or carrying out a multi-stage errand. The standard approach, ReAct, processes the whole procedure as one long flow of reasoning and acting. As the steps pile up, the model starts to hallucinate: forgetting earlier instructions, taking irrelevant actions, drifting off-plan.
Anyone who has watched an AI agent attempt a 30-step task has seen this failure mode. The first ten steps go fine. By step twenty, the agent is confidently doing something nobody asked for. The longer the horizon, the worse it gets — which is a serious problem, because the economically valuable tasks (running errands, managing workflows, operating robots) are all long-horizon.
The org-chart insight
ReAcTree’s fix is structural. Instead of one agent trying to hold the entire plan in its head, the system builds a hierarchy: a top-level agent manages the overall goal and assigns detailed sub-tasks to lower-level agents, each responsible for a subgoal. It is, as the researchers describe it, like a corporate organizational chart — the CEO does not micromanage every employee; she delegates, and each layer handles its own scope.
This does two things. First, it bounds the context each agent must track — a sub-agent working on “buy the ingredients” does not need to remember the details of “plan the menu.” Second, it localizes failure: when a subgoal goes wrong, the hierarchy can re-plan that branch without scrapping the whole mission. Hallucination, in this framing, is largely a symptom of asking one mind to juggle too much. Give it a smaller job and it stops making things up.
The numbers
The results, as reported by ETRI and covered by TechXplore in July, are stark:
- 72B model + conventional ReAct: 31% task success rate.
- 72B model + ReAcTree: 61% task success rate — nearly double.
- 7B model + ReAcTree: 37% task success rate — beating the 72B model’s 31% with the conventional method.
Read that last line again. A model one-tenth the size, given a better planning structure, outperformed the large model given the standard structure. The implication is uncomfortable for the scaling orthodoxy: for agentic tasks, architecture and organization can matter more than raw parameter count. A 7B model that plans hierarchically beats a 72B model that does not.
Kim Do Hyung, director of ETRI’s Social Robotics Research Section, described ReAcTree as technology that “logically deconstructs complex procedures” and can “respond flexibly even in uncertain environments through collaboration among agents.” The team plans to extend it with the ability for agents to resolve uncertainty by asking people questions — the missing piece that turns a clever planner into something deployable, since real-world tasks are full of ambiguities no plan can anticipate.
Why this matters beyond the lab
ReAcTree lands in the middle of 2026’s agent gold rush, and it reframes the conversation. The industry’s default answer to “agents are unreliable” has been “wait for bigger models” — GPT-6 Astra’s long-horizon coding, Claude’s computer-use agents, the whole frontier push toward models that can sustain multi-hour tasks. ReAcTree suggests a complementary answer: keep the model, fix the organization.
The efficiency angle is the one enterprises will notice. If hierarchical planning lets a 7B model do work that previously needed a 72B model, the cost math transforms: smaller models are cheaper to run, faster to serve, and easier to deploy on-premises or on-device. The ETRI result is a single study on specific tasks, not a universal law — but it points in the same direction as the broader 2026 trend, where small models with the right scaffolding keep punching above their weight.
The robotics connection
ETRI’s framing is explicitly about robots and virtual agents carrying out long-term missions — cooking, cleaning, errands. That is the hardest version of the problem, because physical tasks cannot be retried cheaply and mistakes have consequences. A hierarchical planner that doubles success rates in simulation is a step toward robots that can be trusted with a morning routine rather than a single scripted motion. The planned “ask a human when uncertain” upgrade is the bridge from lab demos to homes.
What to watch
Two caveats keep this honest. First, ReAcTree is a research result presented at a conference, not a product — independent replication on diverse task suites will determine how general the gain is. Second, hierarchical systems add their own complexity: more agents means more coordination overhead, more places for miscommunication, and new failure modes at the boundaries between levels. The org chart solves some problems and creates others, just like in real companies.
But the direction is right, and it rhymes with everything else happening in 2026: the shift from single giant models to organized systems of models, each doing what it is best at. The future of AI agents probably looks less like one brilliant mind and more like a well-run team. ETRI just showed that the team structure might matter more than the talent budget. For the small models that benefit most from this kind of scaffolding, see Gemma 4’s efficient family; for where agent workflows are heading in production, see GitHub Copilot Studio.
Featured image: Steve Jurvetson via Wikimedia Commons (CC BY 2.0)
