Autopilot
Autopilot
Have a conversation, ask an exact authorized agent to implement the named work, and it reserves and claims those items before building. Your CI/CD pipeline still deploys the result — without an invisible work router.
Checkout retries
Cursor · on your machine
Empty state for the deployments page
Claude Code · on your machine
Rate limit headers on the public API
Grok Build · on your machine
Invite email from the new org flow
Queued · next in the swarm
Three agents on three tasks, in parallel, mid afternoon.
The Problem
What used to take a sprint takes a conversation
The gap between thinking and shipping has collapsed — but most teams still queue decided work behind keyboards. Someone has to find time, rebuild context, and type out a change everyone already agreed on. That's the bottleneck Autopilot removes.
You're in a session at 2pm discussing a bug. By 2:20 the fix is deployed. You didn't write the code — but you made the call that mattered.
The Mechanics
How it works
Autopilot runs on your machines with your existing coding agents. DevSpec authenticates exact-target requests, coordinates reservations and claims, and keeps the record.
Ask an exact agent to implement
Use a direct implementation surface or send a canonical command to one connection. The server checks owner/delegated command_authority and preserves who actually requested the work.
Explicitly requested items with dependencies and conflicts visibleThe request names the work; DevSpec shows dependencies and conflicts.
The addressed agent reserves, then claims
The agent calls reserve_work_items with the requested ids in order, then claim_work_item one at a time. Atomic claim coordination prevents duplicate implementations without selecting unrelated backlog work.
Active agents across team machines, each working an explicitly requested claimed itemA spare machine becomes a teammate.
Launch a swarm that never steps on itself
Agent swarms are the hype; collisions are the reality. Parallel Mode shows which named items may be safe together using predicted files, shared features, and dependencies. A user selects the set and explicitly launches it; each agent still reserves and claims its requested items. Unknown is never treated as safe.
Parallel Mode on the Agents page: an anchored item with parallel-safe work highlighted, conflicts greyed out with the reason, and several concurrent Running rowsPick one item; everything that can safely run beside it lights up.
Every commit traces back to the conversation
Runners commit with a [devspec:id] tag, and deployment webhooks link the resulting deploy back to the item — and through it, to the session where the team made the decision. Full chain of custody, automatically.
A completed run with its tagged commits and linked deploymentConversation, commit, deploy — one unbroken line.
Failures come back as work, not surprises
A push breaks the build and the failure comes back as a fix item, with the build logs and the commit already attached. Hand it to a coding agent when you want it fixed.
Build failure detected with a tracked fix item and deployment evidenceThe 3am build failure is tracked with evidence by 3:01.
An Index of Capabilities
Autonomy with a paper trail
Worktree isolation
Every run happens in its own git worktree. Parallel runners never trample each other — or your working tree.
Atomic claiming
An item is claimed by exactly one runner, transactionally. No duplicate implementations, no racing agents.
Live run visibility
Watch each run step by step: which machine, what state, what output. Nothing happens in a black box.
Metrics that build trust
Success rates, durations, streaks, and per-type breakdowns. Over time you learn exactly what Autopilot handles reliably — from data, not vibes.
Request coordination
Dependencies, conflicts, reservations, and claims help explicitly requested parallel agents avoid stepping on the same files.
Safe swarms by construction
Parallel Mode reads a live conflict map — predicted files, shared features, dependencies — so a swarm is assembled from work that provably cannot collide. No file data means "unknown", never "safe".
Your subscriptions, working
Runners use coding agents your team already pays for. A user explicitly requests named items; the addressed agents reserve and claim them before implementation.
Explicitly request the week's small fixes on Friday, let the addressed agents reserve and claim them, and start Monday by reviewing pushed branches instead of writing them.
Bring your own agent
Persistent and interactive agents use the same implementation contract. Attach Cursor or Claude Code to a session and send exact-target authorized commands from web or phone — no execution mode or work-delivery queue.
Convinced?
Set up your first project in under five minutes. Connect your repo, start a session, and see what your duck can do.
Start your projectStart with $15of usage, on us · nothing charged until you buy