Multi-Agent Frameworks: The Road to AGI

Written October 2023, when autonomous agent frameworks were the most exciting thing in AI and I was as caught up in it as everyone else. Rewritten in August 2026, with the benefit of knowing what happened. The original claimed AutoGPT “showcases true AGI capabilities” and cited a journal that does not exist; both are addressed below.

In late 2023 a specific idea took hold: if one language model in a loop can do a task, then several of them with assigned roles can do a project. Give one the product manager hat, one the architect hat, one the engineer hat, let them talk, and a codebase falls out.

It was a genuinely good idea and it did not work the way we thought it would. Here is what I wrote about then, where each one is now, and what the failure taught the field.

Where they are, three years later

Framework	Stars	Last commit	State
BabyAGI	22.3k	Jan 2026	reframed as a function framework
AutoGPT	185.8k	Aug 2026	active, now a platform
ChatDev	33.9k	Jul 2026	active, research-led
MetaGPT	69.6k	Jan 2026	active, became a research group
GPT-Engineer	55.2k	May 2025	archived
AutoGen	60.2k	Apr 2026	active, superseded by successors

Star counts as of 2 August 2026. For scale, the original version of this post cited MetaGPT’s “over 17k stars” as evidence the community recognised its potential; it is now at 69.6k, and GPT-Engineer collected 55k stars on the way to being archived. Stars measure attention, and attention is what this whole period had a surplus of.

What I got wrong

“True AGI capabilities”

I wrote that AutoGPT’s ability to write its own code, execute it, and recursively debug “showcases true AGI capabilities.” It did not. It showcased a loop.

What AutoGPT actually demonstrated is that a model with a scratchpad, a shell and no stopping condition will keep going, and that keeping going is not the same as making progress. The characteristic failure of that era was the agent that ran for forty minutes, burned twelve dollars of tokens, and produced a directory of empty files and a plan to write them.

The fabricated reference

The reference list ended with “The Road to AGI: Multi-Agent Systems and the Future of AI, AI Research Journal.” There is no such journal. I cannot reconstruct where it came from; the most likely explanation is that it was generated along with a draft and I did not check it, which is the same failure I found in the Mistral post and the Siamese one. It is removed.

Aggregating instead of running

The larger problem is structural. The post described six frameworks under headings like “Personal Observations and Findings,” and the observations were not personal; they were assembled from other people’s blog posts about the same six repositories. I had run two of them, briefly.

That is why the post reads as uniformly enthusiastic. Everything sounds revolutionary when your source material is announcement posts. Running them was what produced the actual finding, and I did not do enough of it.

What actually broke

The frameworks failed in the same three ways, and the ways are more interesting than any individual project.

Errors compound multiplicatively

A step that is 95% reliable is excellent. Twenty of them in sequence is 36% reliable. Fifty is 8%. The 2023 agent demos were mostly five to ten steps long, which is exactly the range where this is survivable, and the real tasks people wanted were fifty.

per-step reliability   10 steps   30 steps   50 steps
        0.95             60%        21%         8%
        0.99             90%        74%        61%
        0.999            99%        97%        95%

Nothing about role-playing fixes this. Adding a QA agent to review the engineer agent adds steps, and the reviewer is drawn from the same distribution as the thing it is reviewing. This is the arithmetic that the multi-agent framing obscured: more agents is more steps.

Conversation is an expensive way to pass state

The frameworks passed information between roles as natural language in a shared transcript. That is flexible and it is lossy: requirements got paraphrased on each hop, constraints dropped silently, and two agents would proceed happily on incompatible readings of the same sentence.

What replaced it was typed handoffs: structured outputs, schemas, explicit state objects. Less charming, much more debuggable. You can diff a state object.

Nobody could tell what went wrong

When a six-agent run failed after forty minutes, the artefact was a transcript. Not a stack trace, not a failing test, but a long conversation in which the mistake happened somewhere. The tooling that actually made agents usable was tracing and evaluation, and it arrived later because it is less exciting to build.

What survived

The premise was not wrong, only the shape of it.

Role specialisation survived, but as prompts and tool scopes attached to one loop, not as separate autonomous agents holding a meeting. A “reviewer” is a different system prompt and a read-only toolset, not a colleague.
Decomposition survived, and became the main thing. Breaking a task into verifiable subtasks is most of what makes long agent runs work. The 2023 frameworks did the decomposing and skipped the verifying.
The loop survived, with a stopping condition, a budget, and a human at the decision points that cost money.
Tool use survived and became the actual product. What shipped was not the multi-agent company; it was one competent agent with good tools, tight scopes, and traces you can read.

The lesson was not that multi-agent systems are a bad idea. It is that the hard part was never coordination between models. It was reliability of a single step, and adding models multiplies your exposure to it.

On the AGI framing

The original post ended by arguing that multi-agent systems were the path to AGI, on the grounds that human intelligence involves collaboration, competition and coordination, and that emergent behaviour from simple interactions resembles how neurons produce thought.

I do not think that argument survives contact with what happened. It is an analogy doing the work of a mechanism. Ant colonies exhibit emergent behaviour and are not on a path to general intelligence; the emergence in question has to be emergence of the right thing, and “something unexpected happened” is not evidence for that.

What I would say now: multi-agent structure is an engineering pattern with a specific and narrow benefit, which is that separate contexts stop separate concerns from contaminating each other. That is worth having. It is not a theory of mind, and dressing it as one made it harder to see the arithmetic in the table above.