Production AI agent infrastructure
I run a fleet of AI coding agents that ships the software my businesses run on, every working day. This page is the infrastructure view: what has to exist around the models for that to be safe, and where each piece lives.
"AI fleet operator" isn't a job title you'll find on many resumes yet, so here's what it means in practice: I design and operate the systems that let multiple coding agents work real repositories, real boards, and real credentials without a human babysitting every step — and without surrendering control of any of those things. The models are rented. The infrastructure is the part you actually have to get right.
The full narrative is in Running a fleet of AI coding agents in production. What follows is the structural version.
How I run a production fleet
Six layers. Each one exists because something went wrong without it.
1. Work intake
One queue is the system of record for humans and agents alike. Work is scoped before an agent touches it, claims are atomic so two agents can never grab the same ticket, and a mid-flight change of direction lands on the board — not in a chat window. This layer is productized as TaskHarbor.
2. Repository and change control
Agents never see a raw git remote. The transport is mediated: branch protection, PR-only merges, and policy checks enforced server-side where no amount of model confusion can route around them. This layer is productized as RepoHarbor.
3. Credential custody
No agent holds my GitHub token, my cloud keys, or any durable secret. Each one holds a scoped gateway token and asks a control plane for what it needs; the credential it gets back is short-lived, scoped to the job, and revocable per agent. The blast radius of a confused agent is set by what it holds, not by what it was told.
4. Runtime isolation
One agent, one workspace. Agents run in isolated pods with their own checkouts, so a sideways agent strands its own sandbox — never a shared machine, never the fleet.
5. Human approval and audit
Three gates stay human, permanently: what gets built (scope sign-off), what ships (review and merge), and what the fleet may touch at all (credential grants). Everything between the gates is agent work, and all of it — claims, pushes, grants — leaves a log a human can read after the fact.
6. Memory and continuity
The board, the repos, and the docs are the durable state; no agent is trusted to remember anything that matters. An agent can die mid-task and its successor picks up from the recorded state, because operational truth lives in the system, not in a context window.
The evidence
This isn't a whitepaper architecture — it's running. The work-intake layer is TaskHarbor and the transport layer is RepoHarbor, both live products with open-source cores. The credential control plane (FleetHarbor) and the memory layer (NeuroHarbor) are the next two out the door. Every product in the suite is built, daily, by the fleet it manages — the dogfood transcript is the demo. The rest of what I'm building runs on the same loop, including MyPaintBuckets, production software real painting companies run their operations on.
The discipline behind this predates the fleet: I've shipped production AI since 2018, before large language models, and the operating instincts come from twenty years of radar floors, semiconductor test cells, and factory operations — places where "the system must not do the wrong thing" is not a philosophical position.
When to bring me in
Bring me in directly (employment, advisory, or leading your agent-infrastructure effort) when your team wants coding agents but is rightly unwilling to hand them credentials and hope, when multiple agents are already stepping on each other in one repository, or when you need someone who has operated this in production rather than read about it.
Bring in Date Palm Media (my company since 2011) for scoped delivery: software rescue, modernization, automation, and development work where the fleet's leverage shows up as your finished product rather than your new infrastructure.