The Missing Primitive for Agent Swarms — Lou Bichard, Ona
The talk argues that while agent runtimes and orchestration are solved problems, the crucial missing piece for building scalable 'software factories' is a dedicated coordination layer. Current tools like GitHub are inadequate, and a new primitive, potentially a CLI gateway, is needed for agents to manage tasks, pass messages, and navigate the software development lifecycle.
The Vision: The Software Factory
The ultimate goal is to build a “software factory,” defined as the incremental process of moving the human out of the loop within the Software Development Life Cycle (SDLC). This isn’t about a single developer running multiple agents in parallel, but about creating an automated flow where work moves from development to production with minimal proactive human interaction.
While we are in the very early stages of this vision, several patterns for running coding agents at scale have emerged:
- Swarms: A single intent is fanned out to numerous specialized sub-agents, with their work eventually funneled back into a single pull request or task.
- Fleets: Agents are fanned out across many repositories within an organization. This is particularly useful for scaled tasks like CVE remediation, enforcing coding standards, or bumping test coverage across thousands of projects simultaneously.
- Event-Driven: Agents are triggered by events in the existing development workflow, such as a pull request being raised or a ticket being created in a system like Linear.
Major tech companies are already building this infrastructure internally. Stripe created “Minions” to run thousands of PRs, and Ramp recently built a similar system called “Inspect,” highlighting a trend of companies building this critical infrastructure from scratch.
The Three Pillars of Agent Infrastructure
To build a software factory, three core infrastructure components are required. Two of these are largely solved problems, but one critical piece is missing.
1. Runtime (Solved)
This is the environment where an agent executes its tasks. There are various levels of isolation available:
- Threads
- Git work-trees
- Containers
- Virtual Machines (VMs)
For serious development tasks, VM-level isolation is preferable. Containers do not offer a bulletproof security boundary and can suffer from “noisy neighbor” problems and compute contention on shared infrastructure like Kubernetes. VMs provide the necessary isolation to run agents securely and with predictable performance.
2. Orchestration & Triggers (Solved)
The ability to run agents at scale—spinning them up and down horizontally—and to trigger them based on events is a well-understood problem, with existing solutions like webhooks and scheduling systems being readily available.
3. Coordination (The Missing Primitive)
This is the most significant unsolved challenge. Coordination is the mechanism through which agents collaborate, pick up tasks from each other, pass messages, and verify that they have successfully cleared a stage of the development cycle before proceeding.
Current tools are poor substitutes for a true coordination layer:
- GitHub is not for agents: Using GitHub for agent coordination becomes incredibly noisy and overwhelming. When agents raise hundreds of PRs, fix their own CI builds, and resolve merge conflicts, it becomes impossible for a human to determine where and when to intervene.
- Human-centric design: Tools like GitHub and Linear were designed for human interaction, and repurposing them for high-frequency agent communication is an awkward fit.
Deconstructing the SDLC for Agents
A key part of the coordination problem is that agents don’t operate on the coarse-grained, conceptual model of the SDLC (e.g., Plan, Code, Build, Test, Deploy). Each of these high-level stages contains numerous “micro-steps.” To build a reliable software factory, we must break down the SDLC into these smaller, deterministic steps that an agent can follow.
Without this, agents, which are often “sycophantic” and aim to please, may skip crucial steps (like writing tests) to complete a task faster. This is exacerbated by the persistent challenge of “context rot,” where an agent loses track of its objectives as its context window fills up.
A related concept is Harness Engineering, an extension of context engineering. It involves encoding as much process and knowledge as possible directly into the repository—through files like agents.md, detailed unit tests, and defined skills—to create a feedback loop that continuously guides the agent through the software factory.
Potential Solutions for the Coordination Layer
A proper coordination primitive is needed to act as the gatekeeper and state manager for agents navigating the SDLC. The ideal solution would likely be a CLI gateway.
This gateway would allow any local or remote coding agent to invoke a simple command to check its status. For example, an agent could ask, “Have I successfully completed the testing stage for this task?” The gateway would verify the state and respond, giving the agent a clear signal to either fix its work or proceed to the next step.
This approach, combined with concepts from state machines and durable execution, could provide the robust, agent-native coordination layer that is currently missing, finally enabling the construction of true, automated software factories.