Architecture

You decide the direction. We do the architecture pass.

Every ask is read against your repository and written down before a line of code is touched, as a plan when it is work and as a refusal with a reason when it is not. The boundaries are yours: your maintainer.yml says what may be touched, which checks have to pass and which lane keeps a human, and the pass stays inside them.

Request access See the whole run

We run the software side of your business.

No hiring rounds. One onboarding, and every AI dev after it. Consistent senior-level output, around the clock.

No hiring rounds: No job posts, no interview loops, no notice periods, no backfill when someone leaves. You describe the work and the work starts.
One onboarding, every AI dev after it: Your repository is onboarded once to be AI-first: its own rules, its specialist roster, its index. Every AI dev after that is configured for it, whether you run one seat or a thousand, because the context lives in the code and the audit log rather than in one person's head.
Consistent senior-level output: The same standard on a Tuesday morning and a Sunday night: every AI dev runs the same harness and the same prompt cascade, with your repository's own rules layered over ours, and nothing merges outside the review loop and the machine gates you set.

Four things you can read before any code exists.

The read of your repository

Onboarding indexes the checkout once and leaves the repository's own rules beside it, so the pass starts from what your code already does rather than from a description of it. What it leaves is committed to your repository, so whatever opens that checkout next already has it, and a later onboarding run reads it back rather than writing over it.

The plan, as a record you can open

An ask becomes a plan of its own: one record, stamped with the ask it came from, addressable without hunting through the work it produced. Deciding the shape of the work before code exists is the plan, and it is a written artifact rather than a conversation somebody remembers.

The specialist roster for your stack

Onboarding writes a small set of repository-scoped specialists into your own checkout, generated from the stack it detected, so your coding agent routes work to one of them instead of to a generic worker. They are files in your repository: yours to edit, yours to delete.

A routing verdict, or a refusal with a reason

Every ask is judged in one lane, and either routed to work or refused in words you can read. A judgement that never settles is re-run rather than lost, so an ask can be weighed more than once and still lands exactly one verdict and one set of work, because a later pass finds what an earlier one minted instead of minting it twice.

You decide. We deliver.

The architecture pass is work, not authority. What may be touched, which checks have to pass, which lane keeps a human and whether anything merges without you are all written in your own maintainer.yml, versioned in your repository and read on every run. Change it and the next pass happens inside the new boundary. Nothing here overrules a decision you have already made, and nothing merges outside the gates you set.

02The boundary

Your machines. Your keys. Your gates.

We sell orchestration, judgement and the trail. We never resell inference, and we never run the coding agent on our own hardware for a paying customer.

You ownYour boxes

The machines, the keys and the policy

Where it runs: Your own VMs. The runner dials out to the control plane and opens no inbound port.
When it runs: Round the clock. It pulls the next task and streams every event back while you sleep.
Whose model keys: Yours. Every supported provider, plus any OpenAI-compatible endpoint. We never resell tokens.
Who sets the merge policy: Your own .maintainer.yml. Turn auto-merge off, or route a lane through a human, and that is the policy.
Who ships to production: Your own pipeline, after the merge. We do not operate your deploy.

We ownOur servers

Orchestration, judgement and the record

Who decides a merge: One gated merge call. The gate is re-asserted on a fresh read, bound to the commit it validated, and every refusal is a named code.
The record: Append-only and tamper-evident: each row carries the hash of the row before it, so a gap is visible.
Disclosure: Every automated comment says it is a bot. A blank token counts as no token, so it fails toward disclosing.
Other bots: CodeRabbit, Copilot, Dependabot and Renovate are read as signal and never answered. No bot argues with a bot.

The line between what you own and what we are accountable for.

You bring · 01

Access

Repos, APIs, MCP servers and servers. Scoped credentials you can revoke in one move.

You bring · 02

VMs

The boxes the fleet runs on. Developers that do not sleep, on hardware you already pay for.

You bring · 03

AI tokens

BYOK across every supported provider, plus any OpenAI-compatible endpoint.

Three things this page will not claim.

We do not deploy your software

Your own pipeline ships the merge, exactly as it does today. What we record is the verdict your deployment reports back, and putting anything into your production stays a decision you take with your own tools.

UI and UX are planned, not built

The roster of jobs a run can be doing is a closed list, and there is no design role on it. Until there is, nothing on this site sells you a visual design pass.

The code is written on your machines, in your agent

We stay a thin orchestrator: the pass settles the shape, and the writing happens in the coding agent on your own box, under your own keys. We never run that agent on our hardware for a paying customer.

Read further

Where every claim on this page comes from.

The whole run
Every stage from the ask to the merge, one at a time.
The AI devs
Which job each one does, and which one it never does.
Your stack
How a repository is recognised, and what recognition actually buys.
The policy file
Every boundary and gate this page hands you, in the file that holds them.

Ship more. Maintain less.

We expect software to be written faster than any team can review it. Bring your repos, your boxes and your keys. We bring the org that keeps up.

Request access mcp.developerz.ai