Agent Orchestration in Your Repo: What Ships While the Machine Goes In

You're already convinced. That's the strange part.

Most of the engineering leaders we talk to have stopped arguing about whether agent orchestration works. They've seen the first-hours magic, hit the reliability wall on real work, and understood — sometimes from experience, sometimes from the previous piece on this site — that the difference between the two is an engineering investment: harnesses, specs-as-code, review gates, CI, evals. At some point they've said, in a meeting, out loud: "we should do this properly."

And then nothing happens. Not because anyone changed their mind — because standing up the machine feels like a project in itself, and nobody has room for another project. So the decision quietly slides a quarter. The experiments keep producing impressive branches and a broken main, and "next quarter" keeps being the answer.

That fog is the real blocker, and it isn't doubt — it's the absence of a picture. So here is the picture: what an agent orchestration setup engagement actually consists of, phase by phase — what goes into your repo, what ships while it's going in, and what it costs your team in hours, because the hours are the number you're actually afraid of.

What I won't give you is dates. Not because the timeline is embarrassing, but because it's different for every repo — and the phase that tells you yours is the first one. I'll come back to that.

Phase 1: the audit

Nothing touches your code yet. We map the delivery path you actually have: repo structure, CI maturity, test coverage, review culture, what the backlog looks like, and how much vibe-coded debt is buried where nobody has looked since it demoed well. Out the other end comes a plan: where agents will help first, where they won't help at all, and what the machine for your repo — specifically yours — looks like.

Two things about this phase that surprise people. First, the "where they won't help" list is as load-bearing as the rest of the plan; a system that routes the wrong work to agents fails slower and more expensively than one that routes nothing. Second, this is the phase that tells you the real timeline for your repo. Hold that thought.

Your cost: three or four hours. A kickoff call, getting us access, and written answers to questions as they come up. Answer in writing even when a call feels faster — every written answer becomes context the machine itself uses later, and you stop paying the re-explain tax.

Phase 2: the machine goes in

The build. Claude Code harnesses for the work itself; Paperclip when the work needs multiple agents under one board; specs-as-code so intent lives in the issue rather than in anyone's head; review gates nothing routes around; CI wired where agents cannot edit it; evals that tell you when quality slips; escalation paths for the work agents shouldn't decide alone. Every piece versioned and reviewed like the production code it is — so when the machine misbehaves later, the fix is a diff, not a scolding.

Work ships during this phase, deliberately small: a bug fix, a logging improvement, pushed through the new gates as systems checks. Access works, CI catches what it should, the review gate holds, the eval fails when it's supposed to. Boring on purpose — boring is the acceptance criterion.

Your cost: a handful of hours, and they're mostly decisions. What agents may never do without human approval — spend money, touch production, merge to main. Where escalations land. Who reviews what. These are policy calls only you can make, and they get made once, in writing, where they stay made.

Phase 3: first real work through the gates

No toy tickets. Real backlog — items with dependencies and consequences, the kind that burned you last time — starts moving through the system while we tune it.

One thing matters more than anything else in this phase: review the machine's first pull requests at your existing bar. Not below it — not because the author is a machine, not because the setup is new, not because the diff arrived fast. This is the phase that answers the fear you probably haven't said out loud: that agent-written code means plausible-looking changes that fall over in month three. The answer isn't a promise from me — it's a diff in your review queue, with tests, migration safety, and no drive-by rewrites of things that weren't broken. And when a change doesn't clear your bar, the machine gets fixed, not excused: gates tightened, specs sharpened, evals extended. That's not a rough start to manage around. That's the system doing the exact thing it exists to do, while the stakes are still small.

Your cost: the reviews — a couple of hours per pull request early on, dropping as the gates earn trust. These are the highest-leverage hours of the entire engagement; they set the quality bar and the trust level for everything after.

Phase 4: real backlog, tuning, handover

Steady operation, and the division of labor the whole thing exists for. Agents take the mechanical bulk: they map the codebase — dependency structure, dead code, where the bodies are buried — and the output gets used as a guide, not gospel. Your engineers hand-read the deploy path, the auth flow, the money-touching code: the places where being approximately right is the same as being wrong. Blocked means blocked — an agent that can't proceed names who must act and on what, instead of guessing.

Meanwhile your team's job collapses into the shape it will keep. What you should notice: options coming toward you. "The auth refactor is small if we drop the legacy session path — is anyone still on it?" Decisions, not status. If you're still chasing status by this phase, the cadence is broken and we fix the cadence — that's a machine defect like any other.

Your cost: an hour or two a week. Short written updates that read in minutes, one call about trade-offs, the occasional decision only you can make.

What it looks like when the machine is working

Your engineers operate as product owners of an agent fleet. Intent goes in as specs; the gates hold the line without anyone's vigilance being the load-bearing element; what reaches a human is outcomes and decisions — work to accept, escalations only a human should own. Merges are boringly reliable. We stay on support — harness upgrades as models change, eval maintenance, an engineer to call when the machine surprises you — but the machine is yours, in your repo, owned by you.

When you get there depends on the repo you start from. A codebase with real CI, healthy coverage, and a working review culture crosses quickly; one with none of those is building the foundation and the machine together, and pretending otherwise would just relocate the lie. I'm not going to paper over that variance with a number, because any number I name without seeing your repo is a guess — and the audit exists precisely so nobody has to guess. That's not a hedge. The first deliverable of the engagement is the honest timeline for your codebase. If you want your number, that's the conversation to have.

And so you know what you're buying: the machine is never finished. Model upgrades break harnesses. Evals rot unless tended. Some work should never go to agents at all — genuinely novel architecture, ambiguous product bets — and a working system routes it to senior humans instead of pretending. We run our own company on this exact discipline, which is how we know where it ends.

The project you were deferring

Notice what the phases add up to: at no point does your roadmap stop. The audit costs you a few hours of conversation. The build ships its own systems checks. And from the first gated pull request onward, the backlog that's been sliding quarter to quarter is the material the machine gets tuned on. The thing you were deferring isn't a pause in shipping — shipping is how it's built.

Everybody can vibe code — we know how to ship proper software with AI agents.

What the machine consists of — and how we build it with you — is Agentic Setup & Support. Tell us your stack and what you're trying to ship, and we'll tell you exactly what the orchestration system for your repo looks like — and where agents genuinely won't help.