An autonomous coding loop that ships merged code while you sleep.
Keelen runs claude code against your repo in an isolated VM — 24 hours a day. Hand it your roadmap once. It picks up tasks, writes the code, runs the tests, opens a pull request, and — when CI is green — merges it. Want a human gate? Turn on plan-review or manual-merge.
01 — The loop, productized
Not an agent in a chat window. A process in a sandbox.
PILLAR 1
Runs 24/7
The loop doesn't stop when you do. Keelen keeps iterating on your backlog around the clock inside a dedicated Fly Machine.
PILLAR 2
Isolated VM sandbox
Every iteration runs in an ephemeral, non-root container. Your code never leaves your Fly org; egress is allow-listed at the network layer.
PILLAR 3
Ships merged code — or waits for you
Every iteration opens a PR, gates it on your tests, and — by default — merges the green ones to your branch. Want eyes on it first? Turn on plan-review (PO + dev sign-off) or manual-merge and nothing lands until you say so.
02 — Operator console
You watch the loop run, not the agent think.
The console shows the iteration that's running right now — phase, model, tokens spent, tests passing — plus the trail of everything that came before.
03 — Setup
Four steps. Maybe ten minutes.
Connect GitHub
Authorize GitHub and point Keelen at a repo. It works on your branches and opens PRs — it never touches main directly.
Hand off Claude
Log in once with your own Claude account — API key or OAuth. The loop runs on your tokens, billed to you at cost — no markup, no shared keys.
Drop in tasks
Write a Request in plain language. Keelen turns it into prioritized roadmap items and dev-ready tasks with acceptance criteria.
Press play
Start the scheduler and walk away. It picks up tasks, writes the code, runs the tests, and opens pull requests while you sleep.
04 — Roadmap-driven
Your roadmap is the prompt.
Drag a task to Next and it runs next iteration. Add an acceptance criterion and Keelen reads it. Lock a lesson and it graduates to a rule for every future run.
- Drag a task to Next — it runs the next iteration.
- Lessons stream: Keelen proposes, you lock or dismiss. Locked lessons compound.
- Blocker detection: three failed iters on the same line and Keelen flags you.
- Pause and resume at any iteration boundary — the machine suspends within a tick.
Next
2In progress
1Blocked
1Done
4205 — How it's different
Where copilots stop, Keelen keeps going.
06 — Pricing
Flat tiers. Predictable.
Keelen uses your Claude account, so we don't charge for tokens. We charge for the loop — the scheduler, the VM, the dashboard, the observability. Cancel any time.
- 20 iterations / month
- 1 project
- 1 concurrent run
- 7-day log retention
- Bring your own Claude key
- 200 iterations / month
- 3 projects
- 2 concurrent runs
- 1 scheduled project
- 30-day log retention
- Email support
- 1,000 iterations / month
- 10 projects
- 5 concurrent runs
- 5 scheduled projects · 24/7 loop
- 90-day log retention
- Priority support
- 5,000 iterations / month
- 30 projects
- 15 concurrent runs
- Unlimited scheduled projects
- 5 team seats
- 1-year log retention
- Dedicated support channel
07 — FAQ
Reasonable doubts.
Things people ask in the first call. Email us if yours isn't here.
Do I need a Claude Max plan?
No. Keelen runs on whatever Claude credentials you connect at setup — a Claude API key or an OAuth login. We don't resell tokens; usage bills to your own Anthropic account at cost. Other engines (GLM and more) are supported too, so you're not locked to one provider.
What does Keelen see of my code?
Nothing on our infrastructure. Your repo is cloned into a Fly Machine that's yours for the project's lifetime — we provision and orchestrate it but never read the volume. The only data flowing back is the iteration log (with redaction filters) and timeline metrics.
How does it avoid blowing up my codebase?
Every iteration branches first, runs your test suite as a gate, and opens a PR. By default Keelen merges that PR once CI is green — but you're never locked into that. Three ways to keep a human in the loop, per project: turn on plan-review and a PO/SM plus a developer sign off on the plan before any code is written; set merge to manual and Keelen opens the PR but leaves the merge button to you; or branch-onlyand it pushes a branch without opening a PR at all. Per-project rules and an "acceptance criteria" budget also have to be satisfied before a task is marked done.
What if it gets stuck?
Each iteration has a 4-hour wall-clock cap. Three failed iterations on the same blocker and Keelen pauses itself and emails you with the parsed reason. You unblock, click Resume, the loop continues.
Can I self-host?
On Enterprise, yes — we ship the runner image and a Terraform module for your own Fly org. The control plane (scheduler + dashboard) stays SaaS but never reads your code.
What languages does it support?
Anything Claude Code handles. We've tested heaviest on TypeScript, Python, Go, and Rust monorepos. The runner image ships with Node 20, Python 3.12, Go 1.22, and Rust stable; you can extend it with a per-project Dockerfile overlay.
What happens when the Claude CLI updates?
We pin the CLI version in the runner image and run a contract test against its /loginprompt nightly. CLI upgrades are explicit releases — you'll see them in the changelog before they roll to your machine.
Let it run overnight.
See what's in your inbox.
Drop your email — we'll set you up with a free run against a sandbox repo, no credit card. If you like it, point it at your own.