Meta Bought a Tool for Running Coding Agents in Parallel. The Hard Part Is Still Review
Meta's purchase of Conductor shows where AI coding is heading: many agents working at the same time. Why that moves the bottleneck from writing code to reviewing it, and how to work so review keeps up.
- AI coding agents
- parallel agents
- code review
- future of software engineering

On November 4, Meta bought Conductor, a two-year-old startup with one simple idea: instead of working with one AI coding agent at a time, run several at once. Each agent gets its own copy of the codebase, works on its own task, and you review and merge what comes back.
The price was not disclosed, and the team joined Meta Superintelligence Labs, according to Axios and InfoWorld. On the same day, OpenAI announced its own developer-tools acquisition. Big companies are betting that the next step in AI coding is not a smarter assistant, but a team of them.
I think they are right about the direction. I also think most of the conversation is about the easy half.
Why parallel agents make sense
Agents are already normal. In JetBrains’ 2026 survey of more than 15,000 professional developers, 90% said they use AI coding agents at work at least weekly and 68% use them daily. Once an agent can handle a task on its own for twenty minutes, waiting for it feels wasteful. So you start a second one on another task. Then a third.
Tools like Conductor make this practical. They isolate each agent in its own working copy, so the agents do not overwrite each other, and they give you one place to watch progress.
For a certain kind of work this is a real multiplier: small bug fixes, test coverage, dependency upgrades, a new endpoint that looks like ten existing ones, migrating code from one API to another.
The bottleneck moves to review
Here is the part that gets less attention. Writing code was never the slowest step for experienced teams. Understanding the change, checking it against what the product needs, and being confident it will not break something at 2 a.m. was always the expensive part.
When one agent writes code, you review one change. When five agents write code, you review five, often touching the same areas, each written in a slightly different style, each confident it is correct. Generation scales with the number of agents. Your attention does not.
I see three ways this goes wrong:
- Rubber-stamp review. The diffs look plausible, tests are green, and after the fifth one you stop reading. This is how subtle bugs, security holes and leaked secrets reach production.
- Merge conflicts in meaning, not text. Two agents can each make a reasonable change that is wrong together, for example two different ways of handling the same error.
- Ownership fades. Six months later, nobody on the team can explain why a piece of code is shaped the way it is, because nobody really decided.
How I would work with a team of agents
If I run several agents, these are the rules I hold myself to.
- One clear task per agent, written down. A sentence like “add rate limiting to the login endpoint, 5 attempts per minute per IP, return 429 with Retry-After” is reviewable. “Improve auth” is not.
- Small diffs only. If an agent’s change is too big to read in ten minutes, I ask it to split the work. A big diff from a machine is not cheaper to review than a big diff from a person.
- Tests that I trust, before the code. I want the tests to describe the behaviour I asked for, not the behaviour the agent happened to build. When the agent writes both, read the tests first.
- Do not parallelise the risky parts. Payments, authentication, data migrations and anything involving secrets get one agent at a time, and a slow review.
- Keep a running log of decisions. Why we chose this queue, this error format, this library. Agents can read it, and so can the next person on the team.
My take
Running many agents at once is going to be normal, the same way running many CI jobs at once is normal. But I do not think the winners will be the teams that run the most agents. They will be the teams that review best: clear tasks, small changes, tests that encode intent, and engineers who still understand the system.
For developers, that is good news. The skill that becomes more valuable is not typing speed, it is judgement: knowing what to build, how to check it, and when a change that looks fine is not. Those skills are harder to automate than code.
If you are bringing AI agents into your team’s workflow and want help setting up review and testing so speed does not turn into risk, send me a message. For background, see what has really changed in whether AI agents will replace developers.