# How One Founder Manages 20 AI Coding Agents at Once

Ryan Carson, Untangle | AI Engineer NYC 2026 | 15:29

Source: https://www.youtube.com/watch?v=BTtyguoPvBU
Channel: AI Engineer (https://www.youtube.com/@aiDotEngineer). Summarised by AIE Talks.
Page: https://aietalks.com/talks/how-one-founder-manages-20-ai-coding-agents-at-once
Published: 2026-11-09
Tags: agents, coding-agents, human-in-the-loop, multi-agent, software-factories

## TL;DR
- Untangle uses an engineering manager agent to coordinate as many as 20 builder agents through a Linear ticket board.
- Every feature includes review loops, QA, and a recorded video that Ryan Carson watches before approving shipment.
- Untangle evaluates candidates by having them record themselves shipping a real feature, then uses an agent to rank the videos before a paid trial.

## Summary
Ryan Carson explains how Untangle runs software development with cloud-based agents. Human leaders set priorities and speak with manager agents, while those managers assign tickets to builder agents and handle their technical questions. A 15-minute automation checks child sessions so work keeps moving. Builders use review agents, QA agents, and a merge queue manager, with review loops capped at three rounds. Carson keeps one human approval step: he watches a recorded video of each feature before it ships. He also argues that local coding prevents teams from using this model effectively. Untangle's hiring process follows the same approach. Candidates record a roughly 45-minute screen video while shipping a feature. An agent ranks the submissions, five candidates receive a paid 16-hour trial, and their work is reviewed through recorded video. Carson is direct about the bottleneck: the human still has to understand what the product does before approving it.

## Key ideas
### Untangle puts humans above manager agents
[01:49](https://www.youtube.com/watch?v=BTtyguoPvBU&t=109s)
Untangle keeps humans at the top of the organization. They set priorities and speak with customers. Under them are manager agents, which Carson describes as sessions rather than a special new system. Untangle uses Devin for this work. Carson's manager session is called "engineer manager," and it never writes code. He mostly talks to it using audio because he absorbs spoken information more easily than text. The manager works from a Linear ticket board, which acts as the source of truth. Each ticket should become one pull request, and dependencies determine which tickets the manager pulls next.

### One manager agent coordinates up to about 20 builders
[03:07](https://www.youtube.com/watch?v=BTtyguoPvBU&t=187s)
A manager agent concurrently manages up to about 20 builder agents, although Carson says the number can range from five to about 25. The human never enters or directly manages the builder sessions. The manager answers technical questions and unblocks small issues. Untangle also runs an automation every 15 minutes that makes the manager read every child session and push work forward. Carson does not rely on the manager to remember this process on its own. He says the automation is needed because the agent is not deterministic.

### Review loops stop after three rounds before escalation
[05:03](https://www.youtube.com/watch?v=BTtyguoPvBU&t=303s)
Each builder agent calls a review agent. Untangle usually allows about three review rounds. If important bugs remain after those rounds, the issue goes back to the manager agent, which can escalate it to Carson. The process also includes a QA agent that runs as a child of the builder. Carson says agents are inexpensive to add as long as they do not slow the merge queue. The practical limit is coordination. Too many reviews can leave pull requests being repeatedly examined instead of merged.

### Recorded feature videos keep a human in the approval loop
[06:24](https://www.youtube.com/watch?v=BTtyguoPvBU&t=384s)
Every builder records a video showing the feature being used and its tests passing. Devin has this built in through its test feature, which creates test cases and records the result as green or red. Carson watches the green video to check that the expected behavior is present and that the interface looks right. The manager tells him when a video is ready. He still has to read the feature summary, understand what the pull request does, and watch the video carefully. Carson says this is the part product owners will want to skip, especially when viewing on a phone, but he will not approve a feature without watching it properly.

### Cloud sessions let several engineering managers coordinate
[08:18](https://www.youtube.com/watch?v=BTtyguoPvBU&t=498s)
Carson tells developers to stop coding locally because local development prevents the team from using this cloud-agent structure. At team scale, several people can each have an engineering manager session, and those sessions can message one another. They exchange information needed to unblock work rather than casual conversation. Carson says these sessions need to know who the other sessions are. He considers their communication a useful part of the system because the managers can coordinate work without every question returning to a human.

### A merge queue manager handles collisions between agents
[09:36](https://www.youtube.com/watch?v=BTtyguoPvBU&t=576s)
Untangle adds a merge queue manager to coordinate the large number of pull requests coming from the builders. One example is database migration numbering, where independent agents could otherwise choose conflicting values. The merge manager coordinates this work and makes the queue more intelligent. Carson describes it as another ordinary session in Devin, with a name that makes its role clear. Untangle also uses GitHub merge queues. The manager exists because adding more builders creates coordination problems even when the individual coding tasks work well.

### Untangle tests agent operation instead of starting with interviews
[11:07](https://www.youtube.com/watch?v=BTtyguoPvBU&t=667s)
Carson says Untangle does not use pre-screens or early video calls for most candidates. He believes those conversations introduce noise because interviewers may respond to a candidate's hobbies, speaking style, or personality. Candidates instead submit a roughly 45-minute whole-screen recording while shipping a feature or pull request on an app they already maintain. The exercise is intentionally open-ended. Carson wants to see how well each person operates an agent. Candidates do not get paid for this first step, which is how they enter the process.

### An agent ranks candidates before five people receive paid trials
[12:24](https://www.youtube.com/watch?v=BTtyguoPvBU&t=744s)
Untangle feeds candidate videos and transcripts into a ranking agent and asks it to stack-rank the applicants. Carson initially distrusted the ranking, but later concluded that the top-ranked person was the candidate he should have hired. The company selects the top five for a paid project. Each person receives a fixed fee for 16 hours, a Devin seat, and a request to prepare a real pull request for merge. Untangle records the project, feeds the videos into its agent, and uses that material to choose a finalist. Carson then makes a human call with the finalists.

## Notable quotes
- "Each of these builder agents uh has a uh a review agent that it calls upon." (05:03)
- "You've got to watch the video." (07:24)
- "If you're coding locally, stop." (08:18)
- "All that matters is can they operate an agent?" (11:38)
- "We pay them a fixed fee for 16 hours of their time." (13:21)

## Tools & references mentioned
- Untangle
- Devin
- Linear
- Cursor
- GitHub
- Loom
- OpenAI
- Dale

## Who should watch
- You are deciding how to divide work between human engineers, manager agents, and builder agents in a cloud development setup.
- Your team is adding more coding agents and needs a process for reviews, QA, feature approval, and merge queue coordination.
- You are redesigning engineering hiring around practical agent use instead of interviews and want to compare Carson's recorded-work trial process.

## Editor's note

From the pack [Software factories](https://aietalks.com/packs/software-factories):

Horthy's factory lost track of what its own code meant. Snyder needs real production cases, and Klaassen improves his process by studying what each run got wrong. Kitaru records those runs so a team can replay selected cases after changing a model, tool or workflow and check the new behavior before the factory sends it back into production.

Written by the AIE Talks editors (the Kitaru team), not by the speaker.

## Related talks

- [Collaborative AI Engineering: One Dev, Two Dozen Agents, Zero Alignment](https://aietalks.com/talks/collaborative-ai-engineering-one-dev-two-dozen-agents-zero-alignment) (Maggie Appleton, GitHub, 17:43)
- [Building an Autonomous Engineering Org](https://aietalks.com/talks/building-an-autonomous-engineering-org) (Angie Jones, Agentic AI Foundation, 17:36)
- [Agents for Everything Else](https://aietalks.com/talks/agents-for-everything-else) (swyx, AI Engineer, 14:10)
- [Using agents to build an agent company](https://aietalks.com/talks/using-agents-to-build-an-agent-company) (Joao Moura, crewAI, 13:46)
- [I Turned Coding Agents Into a Strategy Game](https://aietalks.com/talks/i-turned-coding-agents-into-a-strategy-game) (Ido Salomon, AgentCraft, 14:50)
