# Dark Factory: OpenClaw Ships Faster Than You Can Read the Diff

Vincent Koc, OpenClaw | AI Engineer Europe 2026 | 16:44

Source: https://www.youtube.com/watch?v=pmoDeA3RBZY
Channel: AI Engineer (https://www.youtube.com/@aiDotEngineer). Summarised by AIE Talks.
Page: https://aietalks.com/talks/dark-factory-openclaw-ships-faster-than-you-can-read-the-diff
Published: 2026-06-05
Tags: agents, coding-agents, evals, harness-engineering, multi-agent

## TL;DR
- OpenClaw's maintainers organized dozens of coding agents into swim lanes for features, bugs, tests, releases, and other work.
- The great refactor changed close to a million lines across 82% of the core codebase and shipped a plugin architecture after 2,700 commits.
- Managing agents at this scale depends on noticing when their reasoning stops making sense and stopping or redirecting the session.

## Summary
Vincent Koc describes how OpenClaw's small group of maintainers manages an unusually large number of coding-agent sessions. He and Peter Steinberger ran roughly 60 to 70 agents, with about 15 visible work lanes, while working on NemoClaw and a major refactor. The lanes divide work by type, so some agents can run with little supervision while others need an ongoing conversation. Koc says the hard limits are now compute and human attention rather than tokens. He watches an agent's explanation as closely as its code, looking for waffle or signs that it does not understand the task. The team also uses Git work trees, reusable skills, PR triage, and evaluation loops built around a fake Slack environment. The talk's practical argument is that high-volume agent work needs management habits and engineering around the sessions. Koc treats the maintainer as a factory manager who decides what work to assign, what to stop, and what deserves review.

## Key ideas
### Coding agents turn engineers into managers of production lanes
[03:08](https://www.youtube.com/watch?v=pmoDeA3RBZY&t=188s)
Koc compares the current shift to industrial production. Earlier factories were limited by the weaver's hands, while today's teams can spread work across repositories and agent swarms. Engineers writing code directly are becoming factory managers, and the bottleneck becomes taste. He says the old ways of working do not fit a world where autonomous agents produce code at high volume. OpenClaw reached a point where Koc was rate-limited by GitHub, which made ordinary manual review and pull-request handling impractical.

### OpenClaw's speed came from organized parallel sessions
[05:38](https://www.youtube.com/watch?v=pmoDeA3RBZY&t=338s)
While working with Peter Steinberger at Nvidia, Koc ran around 10 to 15 coding sessions and Steinberger ran about 15, with subagents bringing the combined total to roughly 60 or 70 agents. Koc describes the visible sessions as swim lanes. The lanes divide work into areas such as CI, features, bugs, Docker, messaging channels, and newly reported P0 and P1 issues. The number of lanes can change from five to 10 or 20. This gives each session a defined job instead of asking every agent to work on the whole project.

### The great refactor used agent volume to cut code into plugins
[07:31](https://www.youtube.com/watch?v=pmoDeA3RBZY&t=451s)
The team had many pull requests requesting features, but Koc says accepting everything would turn the codebase into a 'fire dump.' They chose to split provider code into a plugin architecture, so an organization such as OpenAI, Mistral, or Anthropic could own its provider code separately. The refactor began around 2 a.m. after a folder move disrupted channels and other parts of the repository. It produced 2,700 commits, close to a million lines of changed code, and touched 82% of the core codebase. The tests were heavily over-fitted, but their green status still helped the team tell whether the pieces were close to working.

### Different lanes need different amounts of supervision
[09:42](https://www.youtube.com/watch?v=pmoDeA3RBZY&t=582s)
Koc lets some sessions work with little attention. For test refactoring, he tells agents to take their time, make the tests pass, and commit the changes. Other lanes handle specific features or issues, such as Docker or messaging channels, and require a conversation while the agent investigates and reports back. A separate lane can inspect new P0 and P1 issues using GitHub data. Release-related agents can run in a Discord channel and report what happened during the previous two hours. The factory expands or contracts according to the work.

### Compute and attention have replaced tokens as the main limits
[10:51](https://www.youtube.com/watch?v=pmoDeA3RBZY&t=651s)
Koc says tokens are no longer the central problem. The practical limits are raw compute and the amount of attention he can give to active sessions. His Git work tree setup became a source of trouble because nearly every pull request created another work tree, leaving him with roughly 70 or 80 active work trees in a day. He added recovery behavior around his Codex sessions because a heavy test harness could damage his machine. He also says a simpler setup would have been cloning the repository several times and pointing separate sessions at each clone.

### An agent's explanation can reveal that its work is going wrong
[12:20](https://www.youtube.com/watch?v=pmoDeA3RBZY&t=740s)
Koc says he has learned to 'feel the reasoning tokens' by watching how an agent explains its work. An answer can sound wrong even when the described action does not immediately look wrong. He listens for waffle, incoherent explanations, and signs that the agent does not know what it is doing. He compares this to managing a person who starts to bullshit their manager. When that happens, he may kill the session and leave that part of the code to another maintainer, or return to it several days later. He credits the large amount of agent use in the previous year with building this intuition.

### The agent environment includes reusable skills and feedback loops
[13:09](https://www.youtube.com/watch?v=pmoDeA3RBZY&t=789s)
Koc calls his surrounding setup an agent development environment. He keeps reusable skills in dot-skills, alongside dot-files, for tasks such as technical documentation. He can inspect Codex session logs and ask Codex to improve a skill, then deploy that skill into an open-core or personal environment. He mentions Geppetto as a skills tool he contributes to and points to vercel.skills.sh as a way to find skills. This is ongoing maintenance work around agents, rather than a single prompt that solves every task.

### Maintainers need process for choosing work and checking behavior
[14:28](https://www.youtube.com/watch?v=pmoDeA3RBZY&t=868s)
OpenClaw's pull-request volume led maintainers to try different ways of clustering and searching the backlog, including semantic graphs and vector embeddings. Koc says these approaches can also create noise, so the project needs a way to deduplicate incoming work and identify repeated pressure around an issue. The team also built a fake Slack with synthetic and real models. They use evaluation loops to check that providers and messaging channels work after the refactor. Koc's conclusion is that managing more than 10 agents resembles managing more than 10 staff, where communication and judgment matter as much as the tools.

## Notable quotes
- "The bottleneck becomes taste, you know, that lovely word." (03:28)
- "We have swim lanes." (09:22)
- "It sounds off because of how it's explaining itself to me." (12:35)
- "2025 was about token maxing. 2026 is about not wasting them." (16:12)

## Tools & references mentioned
- Peter Steinberger
- OpenClaw
- NemoClaw
- OpenAI
- Mistral
- Anthropic
- Spotify
- Steve Yegge
- GitHub
- Codex
- Geppetto
- Vercel Skills
- Discord
- Slack
- Docker
- Team Fortress 2

## Who should watch
- You are running several coding agents at once and need a practical way to divide work and decide which sessions deserve attention.
- Your repository is receiving more generated changes than you can review through ordinary pull-request habits.
- You want to build judgment about when an agent is making useful progress and when its explanation signals that the session should be stopped.

## Related talks

- [State of the Claw](https://aietalks.com/talks/state-of-the-claw) (Peter Steinberger, OpenAI, 44:12)
- [Develop at Idea Velocity](https://aietalks.com/talks/develop-at-idea-velocity) (Jeffrey Lee-Chan, Snapchat, 15:28)
- [Containing Agent Chaos](https://aietalks.com/talks/containing-agent-chaos) (Solomon Hykes, Dagger, 23:48)
- [I Run a Fleet of AI Agents Across Three Machines. Here's What Broke.](https://aietalks.com/talks/i-run-a-fleet-of-ai-agents-across-three-machines-heres-what-broke) (Kyle Jaejun Lee, KRAFTON, 09:11)
- [AIE Europe Keynotes & OpenClaw](https://aietalks.com/talks/aie-europe-keynotes-openclaw) (Phil Hawksworth & Lia McBride, AI Engineer & Malte Ubl, Vercel & Raia Hadsell, Google DeepMind & Ryan Lopopolo & Peter Steinberger, OpenAI & swyx, AI Engineer & Vincent Koc, Comet ML & Radek Sienkiewicz, VelvetShark & Sally Ann O'Malley, Red Hat & Nick Taylor, Pomerium & Onur Solmaz, OpenClaw & Merve Noyan, Hugging Face & Fryderyk Wiatrowski, Viktor & Gergely Orosz, The Pragmatic Engineer & Kitze, Sizzy & Matt Pocock, AI Hero & Sunil Pai, Cloudflare, 9:11:01)