AppHandoff · MCP · self-hosted CI fleet
Agent Orchestration.
One operator, a swarm of AI coding agents, a hard release gate. I design and run multi-agent systems that ship 50+ production PRs a day without losing tests, review, or control — and build the same capability for your team.
Most 'AI agents' are a single prompt in a loop. Orchestration is the engineering around the swarm: how agents divide work without colliding, how they coordinate through a shared contract, how their output is evaluated instead of trusted, and how nothing ships until CI, tests, and deploy checks are all green. I run this on my own infrastructure every day — ~55 merged PRs/day on average (peak 111) across roughly 30 parallel agents, 5-minute median merge time — and I build it for teams who want the throughput without the chaos.
What we deliver
Swarm & Coordination Design
How many agents, how they split work, and the coordination layer that stops them colliding. Lane/ticket systems over a shared main branch, MCP-based handoff, and contracts agents can't drift from.
MCP Coordination Layer
An MCP server your agents share as the source of truth — tickets, stages, auto-classification of commits to work items, and auto-close on merge. Built on the same design as AppHandoff, my own coordination product.
Eval Harnesses & Guardrails
Agent output is checked, not trusted: golden-task suites, regression gates, structured logging, and rate limits plus circuit breakers so a misbehaving agent can't take down a system.
Guarded Release Pipelines
A green-only release gate: code ships only when CI, end-to-end tests, and deploy checks all pass. Drain-aware deploys that never kill an in-flight job, plus an autonomous CI auto-fixer that diagnoses failures and opens the fix PR.
Self-Hosted Agent CI Fleet
The infrastructure that makes 100+ PRs/day affordable: a self-hosted runner fleet with shared composite actions, content-addressable caches, and an 8-minute job budget — tuned for parallel agents, not a single human.
Proof it is production-grade
55/day
merged PRs (avg)
30-day average; peak 111 in a single day
~30
parallel agents
running concurrently on a self-hosted fleet
5 min
median merge
queue-to-merged, p90 6 minutes
Why us
Proven at ~55 PRs/day
Not a slide — a measured baseline. ~55 merged PRs/day average over 30 days, peak 111 in a single day, ~30 agents in parallel, 5-minute median queue-to-merge. The system runs this site, AppHandoff, MCP Beast, and the fleet itself.
I Built the Coordination Layer
AppHandoff is my own MCP coordination platform: JSON-RPC over MCP, a realtime kanban of lanes and tickets, pgvector auto-classification of commits to tickets, and auto-close on merge. The orchestration I sell is the orchestration I run.
Governed, Not Feral
Every agent tool call is rate-limited (30/min), circuit-broken (5 failures opens the breaker), and audit-logged. Agents get real access to real systems — with the controls that make that safe in production.
What clients say
Placeholder testimonials — anonymized while real attributions are collected.
“I was skeptical that 'agent orchestration' was anything but a buzzword until I saw the dashboard: ~30 agents in parallel, a five-minute median merge, every PR gated on CI, tests and deploy checks. He didn't sell us a demo, he showed us the same system running his own products. We adopted the MCP coordination layer internally and our throughput roughly tripled.”
— D.R., Head of Engineering, Series A fintech “We'd burned money on a 'Cursor and a prayer' contractor before. The difference here was the engineering around the agents, the lane system, the eval harness, the MCP handoff so agents don't collide. Shipping velocity went from a couple of PRs a week to dozens a day, and the work was actually reviewable.”
— L.M., CTO, bootstrapped dev-tools startup “We had three engineers and a Lovable prototype that wouldn't survive real traffic. Roeland's agent swarm rebuilt it on Next.js with our auth and Stripe wired in, and the release gate meant nothing shipped red. We watched ~50 PRs a day land without a single broken deploy. It felt less like an agency and more like renting a working engineering org.”
— M.K., Co-founder, seed-stage B2B SaaS “Our Lovable app ranked nowhere and broke every time we touched it. The migration to a self-hosted Next.js codebase we actually own took weeks, not the quarter our last quote assumed, because the agents do the typing and the gate keeps the quality. SEO continuity held and we finally stopped paying the vendor-lock-in tax.”
— S.A., Founder, pre-seed marketplace “What sold me was the honesty about the hard release gate: code only ships when everything is green, full stop. That discipline is what let us trust automation touching billing and customer data. The audit trails and circuit breakers were already there because it's how he runs his own infrastructure, not a bolt-on for us.”
— J.T., VP Product, growth-stage healthtech “We needed automation wired into our real CRM and inbox, not another brittle Zap that dies when a field renames. He built agent-driven workflows with auth, rate limits and a green-only release gate, and they've run unattended for months. The fact that he depends on the same automation daily is why I trusted it in production.”
— P.V., Operations lead, mid-market e-commerce
Want your team shipping at agent speed — safely?
Tell me what you're building and where the bottleneck is. I'll tell you what an agent swarm can realistically own, what the coordination layer and release gate should look like, and what it costs to stand up.
Get in touchFAQ
What is AI agent orchestration?
Agent orchestration is the engineering that lets multiple AI coding agents work as a coordinated team instead of stepping on each other. It covers how work is divided into lanes, how agents coordinate through a shared contract (usually an MCP server plus a single main branch), how their output is evaluated, and how a release gate keeps anything from shipping until CI, tests, and deploy checks are all green. The agents do the typing; the orchestration makes the result trustworthy.
How many PRs a day can a swarm of agents actually ship?
On my own infrastructure: ~55 merged PRs/day on average over a 30-day window, with a peak of 111 in a single day, across roughly 30 agents running in parallel, at a 5-minute median time from merge-queue to merged. The ceiling isn't the agents — it's how fast and reliable your CI, caches, and release gate are. That's where most of the engineering goes.
How do agents avoid colliding on the same code?
Each agent does isolated work in its own branch or worktree and only merges to main once it's green — so half-finished work is never visible to the others. A shared coordination layer (an MCP server with tickets and lanes) assigns work and tracks state, and commits are auto-classified back to the right ticket. The single meeting point is the main branch; everything else stays isolated.
Is letting AI agents ship to production safe?
Only with a gate. The rule I hold: nothing publishes until CI, end-to-end tests, and deploy checks are all green — agents keep working until they are. Every tool call an agent makes is rate-limited, circuit-broken, and audit-logged, so an agent can't run away with your systems. Safe agent orchestration is mostly about the guardrails, not the model.
Can you set this up for my team, or only run it yourself?
Both. I run this system daily on my own products, and I build the same capability for teams: the coordination layer (often an MCP server), the eval harness, the self-hosted CI fleet tuned for parallel agents, and the guarded release pipeline. Most teams start with one workflow and one or two agents, then scale the swarm as the gate proves itself.