As AI can agents tackle more work, we naturally assign more work to them. The most notable example this week was OpenAI's use of 10,000 concurrent agents to propose a solution to the Navier–Stokes Millennium Prize Problem. That's a lot of agents. How do you keep them all on task?
While I don't know how OpenAI coordinated their agents, I do know a lot about the large scale agent coordination techniques in Intent. Intent is primarily for software developers and therefore aligned with their workflows, but how it enables agent orchestration can underpin a wide range of domains. In fact, developers have used Intent's underlying system for reducing their electricity bill, making restaurant reservations, and more.
But first, what's agent coordination? I'd say: aligning lots of instances of back and forth messaging with AI models that have been trained to use tools in order to make progress on a unified task or goal. Coordination helps agents:
- Not to step on each other's work
- Communicate among themselves: say when they're done, delegate tasks, review each other's output., etc.
- Interface with humans when needed: asking clarifying questions, request permissions, etc.
- Get through workflows in parallel, sequence, and asynchronously
So how does Intent enable all this for developers?
Focused context
Every task runs on its own copy of your files in a dedicated workspace. That isolation keeps agents from overwriting each other's changes. A living spec lives in each workspace and keeps the agents coordinated, recording what got decided and why along the way. The spec allows each agent picking up work to know what came before and what's next.
Agent roles
Human have different jobs (ideally based on what they're good at) and so should agents. Intent comes with a set of default agent roles: a coordinator breaks work into pieces and delegates them; implementer agents write the code; verifier agents check that code against acceptance criteria.
You can also add your own specialists. for example, if your team has conventions worth enforcing (a particular testing approach, a security review step), you can encode that as a reusable role and it shows up in the mix like any other agent.
Intelligent handoffs
When writing the spec for a task, a coordinator agent will outline how to get the work done: in what order, by whom, and how. As each agent makes progress, they can determine if need to wait for something else to happen and wake up only when needed. For instance, an agent can monitor a pull request in the background, answer review comments as they arrive, and push when everything's ready.
Handoffs can happen between agents as well. When an agent determines its work is done it can do a back-and-forth with a new agent to then move things forward. This allows new agents to only carry important information forward.
Many agents, many devices
With isolated workspaces, focused context, agent roles, and handoffs, you can scale. Not just many agents per workspace, but many parallel workspaces, and many workspaces on multiple devices. Yes, that's a lot of work happening at once.
Not that long ago, a single agent finishing a coding task felt like magic. Now we're orchestrating thousands of them across devices. As with many things in AI, developer workflows and tooling are the most mature examples of large scale agent coordination. But the underlying approaches (focused context, agent roles, and intelligent handoffs) apply to a lot more than just writing code.