Agents write the code. You control what ships.
Keelson is the control room for AI software development: approve the plan before anything runs, limit what the agent may touch, get an independent review of the result, and make the ship decision yourself.
The workflow
Every change follows the same controlled loop
A request becomes a persisted plan. Nothing touches the repository until a person approves it, and nothing merges until a person decides it should.
Request a change
Product previewProject
What should change?
An agent writes a plan first. Nothing runs until a person approves it.
Before execution
The permission envelope
Each run page shows exactly what the run may do. Every line corresponds to enforcement on the server: it is a boundary, not a promise.
Branch-only writes
Agent commits land on dedicated keelson-ai/* branches, never the default branch. Enforced structurally, not by prompt.
Path scope you set
The approver can narrow a run to specific paths. Edits outside the approved scope are rejected server-side before anything is committed.
No secret values
Agents see secret names only. Values stay encrypted and are unreachable from agent code, with redaction as a backstop.
No merge or deploy authority
Merging and deploying are human actions. There is no code path that lets an agent do either.
Bounded change size
At most 20 files per run, 200 KB each. CI config and git internals are forbidden paths.
A monthly budget
Every provider call is metered per workspace against a monthly action cap. Hitting it blocks the action, never bills a surprise.
After execution
An independent review before you decide
A second agent pass, honestly labeled as one, grades every completed run.
Fresh context
The reviewer gets the objective and the diff, nothing else. It shares no conversation state with the agent that wrote the change.
A structured verdict
Requirements checked, findings listed, a recommendation given. The verdict is persisted on the review request, not buried in chat.
Two readings
Simple Mode shows what changed and the recommendation in plain language. Developer Mode shows the branch, diff, provider, and tokens.
Human authority
Some things are deliberately human-only
The final decisions stay with people, structurally.
Agents never merge
Every agent change opens as a review request. Approval and merge are human actions, and protected branches can block AI-authored merges outright.
Agents never deploy
Deployment is a separate, human-initiated step. No run ends in production by itself.
Everything is on the record
Each run keeps a full event timeline, and every action lands in the workspace audit trail: who requested, who approved, what changed.
Two views of the same run
Simple Mode gives a founder the plan, the verdict, and the decision in plain language. Developer Mode gives an engineer the branches, diffs, and token counts. Same run, same server-side rules, one toggle apart.
How the two views workBuilt for supervising agents
Runs are plan-approved and single-pass today: one request, one constrained execution, one verdict. Long-running autonomous loops are not built, and that is a control decision as much as a roadmap one.
How agent runs workThe foundation
Serious infrastructure under the control plane
The loop runs on real Git hosting, an encrypted Vault, and an open-source core you can inspect or self-host.
- Git hosting
- Real Git underneath: clone, push, branches
- Secret encryption
- AES-256-GCM under a KMS envelope key
- Agent writes
- keelson-ai/* branches only, plan-approved
- Access control
- Role-based, server-enforced, tenant-isolated
- Bring your own key
- Anthropic or OpenAI-compatible, every plan
- Self-hosting
- Complete product, Docker Compose
Open source
The platform core is AGPL-3.0-only and the CLI is Apache-2.0, both OSI-approved. Self-host the complete product with Docker Compose; the cloud funds the work. Core Git is never gated, on any plan.
Put your agents under supervision
Free includes the full control loop for a founder and one collaborator, with every core Git feature included.