Thirty-Two Workers, One DAG

There is a fantasy in AI right now where you build one big agent, hand it your whole life, and it figures everything out. I tried to want that. Then I built the opposite, and the opposite works.

Forge runs 32 live autonomous workers on a Mac in my house. I just ran forge status to be sure of the count before I wrote that sentence. Not one agent with 32 tools — 32 workers, each of which does exactly one thing, coordinated by a 25-step overnight chain that kicks off at 5 AM and runs while I sleep. Zero cloud.

The whole design is a product decision dressed up as an infrastructure one. So let me make the product argument.

One Big Agent Is a Thing You Cannot Reason About

A monolithic agent fails the way a bad codebase fails: silently, everywhere, and you can't tell which part broke. When the all-in-one agent returns garbage, the failure surface is the entire agent. Was it the prompt? The retrieval step? The model picking the wrong tool? You don't get a stack trace. You get a vibe.

I've shipped product for fifteen years. The first thing you learn is that a system you can't reason about is a system you can't fix, and a system you can't fix is one you eventually stop trusting. So I built Forge as a fleet. Every worker has a single responsibility and a clear contract — defined inputs, a predictable output shape, one job. When something breaks at 5 AM, I don't debug "the agent." I look at which node in the chain went red, and that node does one thing, so the blast radius is one thing.

That's the entire pitch. Everything below is just the roster.

The Roster, By Role

Here's the fleet, grouped by what each cluster owns.

Security. amygdala is the security council — the worker that reviews code for security problems before any of it gets near a merge. It has one job and it is paranoid about that job, which is exactly what you want from a security reviewer. You don't want your security review to also be your feature work. You want it adversarial and narrow.

Code. This is the largest cluster, because shipping code is where the leverage is. code-review runs review on a local model (gemma-4-12B). auto-fix writes the fix and autofix-retro learns from whether the fix held. pr-digest summarizes what's pending, pr-merge lands it, and advisor weighs in on decisions. claude, gstack, and debate round it out — including a worker whose entire job is to argue the other side. Nine workers, one pipeline: review the code, fix what's broken, draft the PR, decide, merge. Each step is a worker because each step is a different judgment, and I want to be able to swap, disable, or distrust any one of them without touching the rest.

Research. A small swarm of scouts that bring the outside world in. arxiv-scout reads papers, article-scanner reads articles, ecosystem-watch tracks the tooling landscape, and model-scout watches for new models worth swapping in. idea-intake and new-project-digest catch raw ideas before they evaporate, and job-scanner scores job postings against my preferences. None of these would belong inside a "code" worker, and none of them need to know how a PR gets merged. Separation of concerns isn't a coding nicety here — it's the reason the research workers can run independently of everything else.

Memory ops. Forge feeds Coquina, my memory platform, and a cluster of workers keeps that memory healthy. consolidation compresses, evolution runs the self-improvement subsystems, cerebellum does reinforcement-learning edge tuning, and basal-ganglia detects habits worth promoting. Underneath them, the indexers: thread-indexer for the telemetry lake, embeddings-backfill for vectors, repo-indexer for code. Memory that doesn't maintain itself rots. These workers are the maintenance crew, and they run on their own schedule because memory hygiene shouldn't be blocked on code review finishing.

Ops and health. The workers that keep the fleet alive. gpu-warmup gets the hardware ready before the heavy work starts. hypothalamus watches capacity and disk. health-check and chain-watchdog are the supervisors — the watchdog watches the chain itself, because a fleet that can't notice its own failure is just a more expensive single point of failure. perf-benchmark tracks whether things are getting faster or slower over time. This cluster is the part most people skip, and it's the part that makes "runs unsupervised overnight" an actual claim instead of a hope.

Site. The smallest cluster, pointed at this website and at me. site-analytics watches the numbers, site-updater keeps content fresh, and morning-briefing writes up what the whole fleet did overnight so the first thing I read with coffee is a report, not a mystery.

That's 32. Six clusters, one job each, no worker that needs to understand another worker's internals to do its own work.

Why Composition Beats Cleverness

Here's the part I'd defend in any product review.

A narrow worker is testable. I can hand job-scanner a real posting and look at the real score. I can't meaningfully "test" a do-everything agent, because its job is undefined. Undefined scope means undefined success means nothing to assert against.

A narrow worker is replaceable. When I learned that a reasoning model was the wrong tool for a scoring task, I swapped the model inside one worker and shipped the fix in an afternoon. Nothing else in the chain knew or cared. That's the payoff of a clear contract: the inside of a worker is private, so you can gut it without touching its neighbors.

A narrow worker composes. The 25-step chain is not 25 features. It's a DAG — a dependency graph — where each step declares what it needs and produces a clean output the next step can consume. gpu-warmup runs before the model work. Security runs before merge. The briefing runs last because it reports on everything before it. The order is the product. The workers are just primitives I trust enough to compose.

This is the same instinct as a design system. You don't hand-roll every button; you build trusted components and assemble from them. My worker architecture is a design system for agents — make it once, make it narrow, make it composable, and stop reinventing the thing that already works.

The Honest Tradeoff

Thirty-two workers is more moving parts than one agent. There's a coordination cost — the DAG, the shared contracts, the watchdog watching the watchman. I pay it on purpose.

I pay it because the alternative is a black box that fails green and I'd never know which part lied. With the fleet, every morning the briefing tells me what ran, what passed, and what went red. When a worker fails, it fails alone, in public, with a name. chain-watchdog caught it. The blast radius is one node. I fix the one node.

That is the whole difference between a system you operate and a system you pray to. I'd rather operate thirty-two small things I understand than pray to one big thing I don't.

If you're building agent fleets and want to talk about composition over cleverness, I'm at reed@grainlabs.io.