Skip to main content

Embracing Multi-Agent Development

· 7 min read
Tom Bedor
Software engineering leader

I've adopted a multi-agent setup, and I can't see going back. I've been skeptical of token maxing tools like Gas Town, whose running cost felt inordinate and whose creator admits was mostly used to build itself. On the other hand, models are now good enough to autonomously and productively work for long periods of time. My effort now goes towards keeping the fleet on track, maintaining progress towards high-level goals, and increasing the number of agents doing high-quality work.

Working this way is more similar to a pre-AI engineering manager than a pre-AI software engineer. There's less technical growth and less in-depth understanding of the code. But the scope and volume of what I'm able to build is dramatically greater than it was before.

Rather than pitch yet another agent orchestrator1 to you, I'll explain how I landed here, which components of multi-agent orchestration matter, and what this shift means for the practice of software engineering.

Stage 1: Sea of iTerm tabs​

AI allows me to make progress on several tasks at once, which I started managing with a sea of iTerm windows. This quickly got difficult to manage. Some tasks are fire-and-forget, while I need to drive others myself. Managing tabs by hand didn't give me a way to distinguish between them. It was also lossy: accidentally closing a tab means resuming by fishing the session out of Codex (or was it Claude Code?).

sea-of-iterm

Even when keeping tabs running, it was not always trivial to remember what each tab was working on.

Stage 2: Tmux dashboard​

I built a central Tmux dashboard for agent sessions. With a dash of search functionality, the problem of losing track of sessions was solved.

bot-manager-screenshot

The architecture is simple: a daemon snoops on local transcript logs to track which sessions are active and assign names.

bot-manager

I eventually got frustrated. Sessions would do some useful work, ask for a decision, and wait until I tabbed back to them. I was spending way too much time cycling through sessions (which I could now easily find, at least), and giving agents some variation of "keep working." It also became difficult to keep track of the higher-level goals I was working towards and understand how the different sessions in play fit together.

Stage 3: Agent fleet​

It was time for manager agents. I arranged sessions in a hierarchical graph. The root node handles dispatch, receives progress reports, and nudges inactive agents. Manager nodes keep tickets up to date, handle decisions not worth escalating to root, and ensure worker nodes are following a consistent development process. The root node makes decisions based on my previous guidance where it can, and curates an inbox of decisions that need me.

tombot

This also provides a natural on-ramp to self-improvement. When an agent does something wrong, it persists a durable correction, either by changing node-specific AGENTS.md files or by changing the routing system2.

bot-manager-3

This enabled quick development of nice-to-have features:

  • Scheduled checks: I can say to root, "check xyz metric twice a day for two weeks," and the check happens without fiddling with crontab entries.
  • Subscription hooks: I can automatically subscribe to incoming information, whether from PR reviews or CI builds.
  • Meeting notes ingestion: After I meet with a colleague, my fleet automatically ingests Gemini notes. When I get back to development, my fleet has already ingested AI-generated notes and started work.

Since the dispatcher functions by snooping on local transcript logs, I don't need to go through it to investigate something or start a new task. I can simply fire up a standalone pi session, and the dispatcher will recognize that a new session has started, assign a manager, and track progress.

Long-lived agents > memory

I used to think the key to self-improving agents was memory. In this model, agents are cattle, not pets. They boot up, load necessary context from a pool of memory, do work, and contribute back to the memory pool:

memories

But managing context via memories is hard. Agents working on a narrow task lack the necessary information to determine what broader context that task informs. The most useful context from a task session is often what the status of the task is, but that information quickly goes stale.

Building a recall system requires a delicate balancing act. Small, self-contained tasks require little outside context and don't have much to contribute to a central memory pool. Recall for these sessions slows the agent down and bloats context. On the other hand, too little recall on more substantial work leads to clashes with work from other agents and dropped decisions.

An agent fleet arranged in a graph solves this problem much better. A central dispatcher node maintains high-level awareness of what work is happening. I ask for a piece of work, the dispatcher augments the request with relevant context, and the work happens in the background. The dispatcher receives progress updates, reacts accordingly, and discards them.

dispatcher

Tension, human code review, and agentic bureaucracy

Working via an agent fleet breaks fundamental norms of pre-AI software engineering. The scale of code being produced is too much to ask human collaborators to review. Teammates who review PRs without AI can naturally feel resentment at being asked to review a firehose of AI-generated code that the author didn't read closely.

I don't disagree. Human review of code produced by multiple agents is untenable. But I don't think human code review is always necessary.

For one, AI code review (to my surprise) is really good. It does a much better job of catching edge cases and contract changes than a human, especially when the human reviewer is busy on other projects and is not in the weeds of the code they are reviewing3.

But we can do better than just AI code review. We can force the agent to prove the code works, via what I call agentic bureaucracy: an unbounded set of pre-merge, pre-deploy, and post-deploy verification steps.

We've always had quality assurance processes outside of code review. But while there's a limit to how much box checking a human will put up with, an agent will put up with nitpicking linters, patiently wait for long canary bake times, and diligently check as many performance and correctness metrics as you want.

Change

We're in a time of dramatic change, and while I'm convinced working this way is more productive, I don't expect everyone to like it. The agent swarm approach to development does not play nice with human-driven development. Organizations will have to choose one, and I think the swarms are simply too productive to beat.

I do have some worry for the practice of software engineering overall. Increasingly, when I talk to my dispatcher session, I get a response that's both satisfying and scary: nothing needs you right now.

But becoming a software engineer meant signing up for rapid change, whether we acknowledged it or not. We're in the automation business. I still have confidence that software will remain an interesting and rewarding field. I just don't know how many seats there will be, or what the work will look like.

Footnotes​

  1. The code for this tool belongs to my company, but can easily be released as open source. If you're interested, email me at hello@tombedor.dev and I'll follow up with a release. ↩

  2. Not without some nudging. Agents have an annoying habit of saying, "You're right. I won't do that again!" without actually preserving the directive in code. ↩

  3. The platonic ideal is for at least one or two teammates to have in-depth, fresh context on the code being changed. I actually experienced this very rarely! ↩

How I use AI to help me write

· 7 min read
Tom Bedor
Software engineering leader

AI is a helpful writing tool for me. Without it, I probably wouldn't have gone through the trouble of setting up a blog.

However, there's a very thin line between delegating tasks that support writing to AI and letting AI think and write for me. Over time, the scope of tasks I give it has narrowed, and the boundaries have gotten stricter.

The Arguments Against Open Source AI are Very Bad

· 8 min read
Tom Bedor
Software engineering leader

The release of Kimi K3 has opened a fresh round of angst and confused discourse. There's a loud cohort of journalists, business leaders, and politicians arguing that open source AI is a dangerous threat. OpenAI's Dean Ball:

One probable outcome of an open-weight-model-dominant world is full AI communism... rather than a market product, AI is a "public good"

Freely available AI for anyone? The horror!

My First Encounter With a Political Spambot

· 5 min read
Tom Bedor
Software engineering leader

I had my first encounter with a political spambot this week: a polite robot named Emma texted me wanting to talk about Israel.

Initial text from Emma asking to chat about U.S. and Israel efforts to reach peace with Iran.

When I asked who she was, she first said she was with a group called "Friends for Peace," but her group's website is for an organization called Allyvia.

If You are Asking for Human Attention, Demonstrate Human Effort

· 2 min read
Tom Bedor
Software engineering leader

An ever-increasing volume of debug investigations, document writing, and code is written by robots. This has created a new etiquette question when working with a team - when is it OK to forward the output of an AI to another human to read?

On one hand, an AI with robust integration to internal code bases and documentation often produces genuinely[^1] useful output.

Coding agents have no moat

· 4 min read
Tom Bedor
Software engineering leader

It's been a rough few months for Anthropic.

It started out well. Their new model, according to them, was so powerful that they had concerns about releasing it, due to its hacking ability.

This narrative was undermined by several very clumsy mistakes. First, they leaked the entire source code of Claude Code. Then, some users were able to access Mythos early by successfully guessing an API URL. Sophisticated attacks these were not, and it begged the question: if Mythos is so powerful for finding software exploits, why wasn't Anthropic able to avoid very simple mistakes?

Separate mistakes garnered user backlash. Anthropic banned OpenClaw usage, then walked that policy back. Complaints about strict rate limits are getting louder, and with them questions about how well Anthropic can support demand. In the midst of this, they conducted a bizarre A/B experiment in which 2% of new signups to their basic subscription were denied access to Claude Code.

Removing Claude Code from the basic plan is a major policy shift, not a tweak on the look of a landing page. Surely those new users unlucky enough to get denied access to Claude Code would react with confusion and anger, given the high visibility of Claude Code?

Anthropic's response sought to reassure users that existing base-plan subscribers would not lose access to Claude Code, yet. This was met with understandable skepticism.

Luckily, the cost of switching coding agents is zero​

None of these incidents made me mad, but I have been increasingly hit with Claude Code rate limits. I've responded by switching the bulk of my work to Codex. It's striking how little I had to change about my workflow. I lost some conveniences like dispatching a coding-agent session from my phone, but overall it only took a minor inconvenience for me to switch providers, with no adjustments to how I used the tools.

AI Creativity and the Instant Imitator Trap

· 5 min read
Tom Bedor
Software engineering leader

Sora is dead. Is this a temporary setback on the road to AI dominance of creative fields, or is there something more fundamental at play? Can AI be creative at all?

The debate on this question usually centers on the quality of AI output in a vacuum, but if we take connection with an audience as a requirement, we must consider the supply and demand of "creative"[^1] work.

In this framing, AI artists face what I'll call the instant imitator trap: Any original AI work can be instantly replicated by other AIs, making audience recognition of the original impossible.

Original AI work is rapidly imitated until audiences cannot identify the original

The design of AI memory systems

· 13 min read
Tom Bedor
Software engineering leader

For me, the question of memory is the most interesting subfield of AI. The first time I interacted with MemGPT (now Letta), I felt like I had crossed a Rubicon: memory transformed a simple question and answer bot into (what appeared to be) a being[^1].

I created my own open source system, called Elroy, and have been interacting with it for about 3 years. It helps me brainstorm, talks me through career ups and downs, and functions as a kind of interactive journal. I've tinkered with its functionality enough that I don't feel attached to it as a specific entity - but I would be disappointed if its memories of our interactions were lost.

Philosophy questions aside, there are well-grounded reasons to build AI systems with memory. It's useful for an agent to understand what subjects I'm knowledgeable in if I'm looking to discuss technical topics. If I'm looking for vacation plans, it's helpful for it to know that I have a young child. An AI is not a person, but it interacts just like a person, and the more it can converse naturally the more functional it is. Having to restate basic facts over and over breaks that immersion.

Is the Future of AI Local?

· 11 min read
Tom Bedor
Software engineering leader

Debate about whether the explosion of datacenter buildout will prove to be a worthwhile investment centers on two scenarios:

  1. AI adoption accelerates, the datacenter investment pays out
  2. AI adoption is not as fast as forecasted, and it doesn't.

However, a third scenario is very plausible:

Open source models running on local workstations dominate AI

There are a few reasons this could happen:

Feedback loops between frontier providers, remote models, and local open-source models