Killing Anthill: Why We Retired Our Agent Orchestration System

On March 25th, 2026, we shut down Anthill for the last time. Ten AI agents, a LangGraph orchestration pipeline, a Slack-based communication layer, and months of work - all archived to a Google Drive backup folder with the quiet finality of a systemctl stop command. The GitHub repos got marked as archived. The code was zipped and filed away. That was that.

This is not a post-mortem about failure. Anthill worked. It did exactly what we designed it to do. The reason we killed it is more interesting: we found something better, and the honest thing to do was admit it.

// what anthill was

Anthill was an autonomous agent colony. Ten specialised AI agents, each with a defined role, communicating through Slack channels and coordinated by a LangGraph pipeline. A virtual team where every member was an AI with a specific job description and a shared communication bus.

The agents had names and responsibilities. A project manager tracking tasks and deadlines. A code reviewer analysing pull requests. A researcher gathering information on demand. A writer producing documentation. A DevOps agent handling deployments. Each operated semi-independently, picking up tasks from a shared queue and reporting results back through Slack.

LangGraph handled orchestration. When a task came in, the pipeline decomposed it into sub-tasks, routed each one to the appropriate agent, collected results, and synthesised a final output. On paper, an elegant solution to the problem of complex, multi-step work requiring different kinds of expertise.

We built it over several weeks. Clean architecture. Modular agent definitions. Well-defined communication protocol. Slack provided a human-readable audit trail of everything the colony did. You could watch the agents talk to each other in real time, delegating work, asking clarifying questions, reporting progress.

For a while, genuinely impressive. A task would come in and ripple through the colony. The project manager would break it down. The researcher would gather context. The developer would write code. The reviewer would check it. The writer would document it. All without human intervention.

It felt like the future of software development. Then reality set in.

// why it worked initially

The early wins were real. Anthill handled multi-step workflows that would have taken a human hours. Research a topic, produce a summary, draft code from the summary, review it, generate documentation - all in a single pipeline run. Reasonable quality. Remarkable speed.

For well-defined, repeatable tasks, the colony was excellent. Boilerplate generation, test suites from specifications, documentation from code comments, competitor research tables. Structured inputs, predictable transformation steps, structured outputs. The sweet spot.

Slack integration gave complete visibility into decision-making. Every agent explained its reasoning. Every handoff was logged. If something went wrong, you could trace the exact sequence of events. That transparency was a genuine advantage over black-box systems.

The modular architecture meant iterating on individual agents without affecting the others. Code reviewer too strict? Adjust its prompt without touching the developer agent. Researcher missing relevant sources? Upgrade its search strategy independently. Each agent was a tunable component in a larger machine.

For about three weeks, Anthill felt like a superpower. Then the cracks started showing.

// what went wrong

The first problem was context windows. Each agent had limited context, and complex tasks quickly exceeded those limits. The project manager would decompose a task beautifully, but by the time the developer agent received its sub-task, crucial context had been lost in the handoff. The researcher would produce a comprehensive report, but the summary that reached the writer was a pale shadow of the original.

Information degraded at every boundary. Every handoff lost something. Like a game of telephone played by ten very intelligent entities who each had amnesia. Individual agents were smart. The collective was surprisingly forgetful.

The second problem was worse: the orchestration layer itself became the bottleneck. LangGraph is a powerful framework, but routing logic accumulates complexity like a magnet collects filings. Edge cases breed more edge cases. Error handling cascades through the pipeline. Retry logic interacts with timeout logic interacts with fallback logic. Within weeks, the orchestration code was more complex than any of the agent prompts, and it was the source of most bugs.

We spent more time debugging coordination between agents than on any productive work the agents were doing. The overhead of running an AI team turned out to be remarkably similar to the overhead of running a human team: most of the energy goes into communication, alignment, and making sure everyone is working from the same information.

The irony was not lost on us. We had built a system to reduce coordination overhead, and the system itself had become a coordination problem.

// the moment of clarity

The turning point came on a Tuesday afternoon. Three hours spent debugging a pipeline failure where the researcher and developer agents had gotten into a loop - each requesting clarification from the other, neither able to provide what the other needed. The task itself? Update a configuration file based on new requirements.

We opened a fresh Claude Code session, described the task in plain language, and had the answer in four minutes. Not four hours. Four minutes. No orchestration. No handoffs. No coordination. Just a single, focused session with all the context it needed.

That was the moment we knew Anthill was dead. Not because it could not solve problems, but because a simpler approach solved them faster and with less friction. The ten-agent colony had been outperformed by a cat with a terminal.

It is well known that a vital ingredient of success is not knowing that what you are attempting cannot possibly work.

- Terry Pratchett, Equal Rites

We had built Anthill not knowing it could not possibly work at the scale and complexity we wanted. That ignorance was valuable - we learned an enormous amount about agent orchestration, context management, and the real dynamics of distributed AI systems. But holding on after we knew better would have been stubbornness, not perseverance.

// what replaced it

Claude Code plus Greebo. That is it. A single AI interface on a single server, with MCP tools for anything requiring external capabilities. No orchestration framework. No agent roster. No Slack channels full of AI-to-AI chatter.

The MCP tools handle the same domain-specific work the agents used to handle, minus the coordination overhead. Need to check email? Tool. Calendar? Tool. Deploy code? Tool. Research something? Claude Code does that natively, without needing a dedicated research agent.

The key difference: one context, one conversation, one decision-maker. Information does not degrade across handoffs because there are no handoffs. Context does not get lost at agent boundaries because there are no boundaries. The entire state of a task lives in a single session.

The memory engine fills the persistence gap. Where Anthill stored state across agents in a shared database, Claude Code now has a FTS5 memory system with salience scoring. It remembers what matters, forgets what does not, retrieves context on demand. Simpler, faster, and more reliable than Anthill's distributed state management.

Tasks that took the colony 30 minutes now take 5. The error rate went from "check the Slack logs every few hours" to "basically never." And we got back all the time we used to spend maintaining the orchestration layer.

// the shutdown

$ colony --shutdown

Shutting down Anthill Colony...

[agent:pm]         stopping... done
[agent:researcher]  stopping... done
[agent:developer]   stopping... done
[agent:reviewer]    stopping... done
[agent:writer]      stopping... done
[agent:devops]      stopping... done
[agent:analyst]     stopping... done
[agent:designer]    stopping... done
[agent:tester]      stopping... done
[agent:monitor]     stopping... done

[langraph]         pipeline stopped
[slack]            channels archived
[state-db]         final snapshot saved

Colony shutdown complete.
Total runtime: 47 days
Tasks completed: 312
Code archived to: gdrive:backups/archive/anthill/

Goodbye, colony.

Three hundred and twelve tasks in forty-seven days. Some brilliant. Most adequate. All of them carrying more coordination overhead than the work itself justified.

// the lesson

The lesson is not that agent orchestration is bad. It is that coordination overhead must be justified by the complexity of the work. If a single agent with good tools can solve the problem, adding nine more agents and a pipeline framework does not make it better. It makes it worse.

There is a strong gravitational pull in AI development toward more agents, more layers, more coordination. It feels like progress. More agents must be better than fewer, right? More sophisticated orchestration must produce better results. The architecture diagram looks impressive. The demo is compelling.

But software is not measured by the complexity of its architecture diagram. It is measured by the results it delivers and the friction it removes. By that measure, ten agents in a LangGraph pipeline lost decisively to one session with good tools and a memory system.

The hardest part of killing Anthill was not the technical work. Code archived cleanly. Services shut down gracefully. The hard part was admitting that something we had invested significant time and creativity into had been superseded by something simpler.

That is engineering, though. The best architecture decision you can make is sometimes the decision to stop. To recognise that the elegant solution has been overtaken by the obvious one. Archive the code, learn the lessons, move on to the thing that actually works.

Anthill taught us more about AI systems than anything else we have built. Context management. The real dynamics of agent coordination. The difference between impressive and effective. Those lessons live on in everything we build now. The code does not need to.

Rest well, colony. You earned it.