Keelen
Sign inGet started
open betaBring your own Claude, Codex, GLM, or Kimi key

An autonomous dev team that ships tested, merged PRs while you sleep.

Keelen turns your roadmap into working software. A PM pass breaks your plain-English requests into tasks with acceptance criteria. Dev runs write the code in an isolated, single-use VM. Five verification gates stand between that code and your main branch — including a proof that the new tests actually catch failure. When everything is green, it merges. When it isn't, you get one plain-English question, not a mess.

Get started↵See the gates
› Your own model key — zero token markup› Five gates before any merge› Single-use VMs, destroyed after every run› Pause, gate, or revoke in one click
A night on the loopsimulated
Fixed checkout race conditionmerged · just now
Added rate-limit middlewaremerged · 4m ago
Stabilized flaky billing testmerged · 11m ago
Shipped password-reset flowmerged · 23m ago
Tightened webhook validationmerged · 38m ago
– PRs merged this week– iterations in 24hfleet-wide · live
[ how it works ]Connect your repoHand over your roadmapWake up to merged PRs
[ runs on ]Claude (Opus & Sonnet)GLM 5.2Codex / GPT-5.6Kimi K3

01 — The backlog problem

Copilots made typing faster. Your backlog didn't notice.

Autocomplete helps while your hands are on the keyboard. Chat agents help while you're writing prompts and babysitting output. But the backlog grows at night, on weekends, while you're in meetings — precisely when nobody is prompting anything.

The bottleneck was never typing speed. It's that software work needs a process that keeps moving without you: something that picks the next task, does the work, checks the work, and only interrupts you for real decisions. That's not an assistant. That's a team.

02 — The loop, defined

Not an agent in a chat window. A process in a sandbox.

Keelen is an autonomous coding loop: an AI development team that runs against your GitHub repository around the clock. It turns free-form requests into a prioritized roadmap, breaks roadmap items into dev-ready tasks with acceptance criteria, implements each task in an isolated single-use VM using your own Claude, Codex, GLM, or Kimi credentials, verifies every change through test and review gates, and ships the result as a merged pull request — or holds it for your review, if that's what you've configured.

PILLAR 1

A PM that never sleeps

Write a request in plain English. Intake classifies it into roadmap items, clarifying questions, and standing rules. Expansion turns the top item into tasks a developer could pick up cold — each with acceptance criteria and a definition of ready.

PILLAR 2

Dev runs, one task at a time

Every iteration gets a fresh clone in a single-use, network-isolated VM, implements exactly one task, and opens a pull request. Small, reviewable, revertible units — the way disciplined teams ship.

PILLAR 3

Ships merged code — or waits for you

By default, green and gated means merged. Prefer eyes on it first? Require plan sign-off before any code is written, keep the merge button for yourself, or take branches only.

03 — The gauntlet

Five gates stand between the AI and your main branch.

Most coding agents generate code and hope. Keelen makes every change prove itself.

plancode① red-first② review③ tests④ CI⑤ windowmerged ✓

Red-first proof

The new tests are applied without the implementation and must fail. Then the implementation lands and they must pass. Tests that were born green are rejected — every change ships with proof its tests can catch a regression.

Adversarial review

A second, independent model reviews only the diff — it shares no context with the run that wrote it, so it can't rubber-stamp its own work. A rejection blocks the merge and leaves the PR for you.

Your tests, actually run

The PR head is checked out clean and your real test command runs — monorepo-aware, timed against your project's own baseline.

CI-green merge gate

Nothing merges over a red required check. A failing test check holds the work and reopens the task; a flaky integration check gets a bounded re-run, not a shrug.

The review window

Gated auto-merge waits out a review window first — and you can replace auto-merge entirely with plan-review sign-off before any code is written, or keep the merge button for yourself.

The contract

The loop is forbidden from weakening your checks: it may not skip a failing test, mark a check non-required, or add continue-on-error to get to green. If it can't fix the real problem, it tells you so — in plain English.

04 — Built for bad nights

Autonomy is easy when everything works. Keelen is built for when it doesn't.

It knows why it failed

Every failed run is classified into one of 30 failure kinds. Infrastructure blips and provider limits never count against your work — only real code failures do.

It retries like an adult

Budgeted retries with exponential backoff per failure class. Provider quota hit? It waits for the reset and resumes itself.

It doesn't spam your board

Post-merge failures reopen the original ticket instead of forking duplicates. Conflicts get healed server-side before any agent time is spent. Duplicate PRs are detected byte-for-byte and closed.

It handles flaky CI three ways

Different-failure holds, bounded re-runs, and an early stop when the same failure signature repeats. Machines never burn on the same red twice.

It fixes flaky tests — properly

Flaky tests get root-cause fix tickets first; quarantine is a last resort and tracked. Deterministic failures are never quarantined.

It knows when to stop

Circuit breakers on every runaway pattern pause the project and tell you exactly why. Every dead end becomes one card in your Needs-you queue with a plain-English ask.

05 — Security & isolation

Your code and keys never leave your control.

Connecting GitHub and your model key takes one click each — and both are built to be taken back just as fast. Here's exactly what happens to them.

A

Least-privilege GitHub, per run

You connect through GitHub's official app and choose which repositories Keelen can see. Every iteration then gets its own access token scoped to one repository, valid for about an hour, with no permission to touch your CI workflows. When the run ends, the token is already dying.

B

Keys sealed, never exposed

Your model key is encrypted the moment you connect it, under independently rotated keys per credential type. It's never stored in plain text, never sent back to your browser, and automatically scrubbed from every log we keep.

C

A VM that exists for one job, then vanishes

Each iteration runs in its own isolated VM with no persistent disk. Credentials are handed to it only while the run executes — then the machine is destroyed. Code, keys, everything on it: gone.

D

The internet, minus almost all of it

Iteration VMs have no direct internet access. All traffic passes through a deny-by-default proxy that allows roughly twenty hosts — your AI provider, GitHub, package registries — and logs every request, including denials.

You're always in control

Changed your mind? Revoke in seconds.

Disconnect GitHub
  1. 1.GitHub → Settings → Installed GitHub Apps
  2. 2.Find Keelen → Uninstall — access stops instantly
Remove your model key
  1. 1.Keelen → Settings → Integrations
  2. 2.Click Revoke — the key is deleted from our database at once

What Keelen can do is bounded by what you grant — and everything it does lands as a pull request in your repo, in the open. Prefer a human gate? Plan sign-off, manual merge, and branch-only mode are one toggle each, and you can pause a project or your whole fleet anytime. Read the full security model →

06 — Setup

Four steps. About ten minutes.

01

Connect GitHub

Install the GitHub App and pick your repos — or have Keelen create a fresh one from an idea. It works on branches and PRs; it never commits straight to main.

● acme/billing-service · main
02

Connect your engine

Claude Code (your Pro/Max subscription or API key), OpenAI Codex, GLM, or Kimi K3. Your key, encrypted at rest; usage billed by your provider at cost — no markup, no shared keys.

● engine · byo key · ✓ ready
03

Write a request

Plain English: “Add magic-link login.” The PM layer turns it into prioritized roadmap items and dev-ready tasks with acceptance criteria — and asks you a question when your request is ambiguous.

● T-088 · P0 · Fix race in finalize → webhook
04

Press play

The loop picks the top task and iteration #1 starts. Watch it live, or close the tab — you'll have PRs and at most a couple of decisions waiting.

● ▶ running · iter#42 · 7m 21s

07 — Bring your agent

The dashboard is optional. Drive the loop from your editor.

Keelen ships a first-class MCP server. Point your coding agent at it and you can sign up, create projects, file requests, reorder the roadmap and clear blockers without opening a browser tab.

One line, no key required

claude mcp add --transport http keelen https://keelen.ai/mcp

Then just ask

  • “create a project that …”
  • “what shipped overnight?”
  • “bump the auth work to the top”
Claude CodeClaude DesktopCursorWindsurfCodex CLIany MCP client

No key to paste

Signup and email verification are themselves MCP tools. Run the command, then say “sign me up” — the server mints your key in the chat.

31 tools

Create projects, submit requests, reorder the roadmap, read status, resolve escalations, kick off a security review.

One pipeline

A request submitted over MCP enters the exact intake path the dashboard uses. Same queue, same planner, same gates.

Signing up, connecting GitHub and creating a project are free. Running the loop needs an active subscription.

08 — Hands-off by default

It only asks when it has to.

Keelen runs the loop in the background — planning, coding, testing, and opening PRs on its own. You hear from it only when it hits a real decision: a blocked task, an ambiguous spec, a call only you can make.

acme/billing-service›todaysimulated
working in the background
shipped on its own · today3 merged
Fix race in PaymentIntent finalize → webhook
T-088 · merged · 12m ago
Idempotency keys on the refund endpoint
T-090 · merged · 1h ago
Apple Pay express checkout sheet
T-091 · opened · PR #312
Backfill currency on legacy charges
T-092 · merged · 3h ago
needs you · 1 decision
T-093
Refunds can target two Stripe API versions. Which should ship?
2024-06-20 — current
2024-12-18 — latest
merged this week14
waiting on you1
pass rate98%
open queue12

09 — 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.
  • Self-curating memory: Keelen learns from every iteration and prunes what stops being true.
  • 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.
simulated

Next

2
T-091feature
Add Apple Pay flow to /checkout
P10/7
T-098improvement
Rate-limit /v1/charges to 60/min/account
P10/4

In progress

1
T-088bug
Fix race in PaymentIntent finalize → webhook
P04/6

Blocked

1
T-082chore
Migrate webhook signing to v2
P12/5

Done

42
T-079feature
Surface decline-code mapping
P25/5
T-076improvement
Backport idempotency-key dedupe
P14/4

10 — Who it's for

Built for the people whose roadmap outruns their hands.

Indie devs & side projects

You own a Claude Max plan. It idles 20 hours a day. Point it at the project you never get to — hand over the backlog, wake up to PRs. From $29/mo.

Start with Indie →

Founders & small teams

The roadmap is 10× your headcount. Run the long tail — the refactors, the test debt, the papercuts — with sign-off gates you set, while your team stays on the hard problems.

Go Operator →

Agencies

Fifteen concurrent machines across thirty client repos. Per-project merge policy, per-client story, one console — and one flat bill.

Go Agency →

11 — How it's different

Autocomplete needs your hands. Agents need your tasks. Keelen needs your roadmap.

Works from a roadmap, not a prompt
Copilot no
Coding agent partial
Keelen yes
Picks its own next task
Copilot no
Coding agent no
Keelen yes
Runs unattended, around the clock
Copilot no
Coding agent partial
Keelen yes
Proves new tests fail before the fix
Copilot no
Coding agent no
Keelen yes
Independent adversarial review before merge
Copilot no
Coding agent partial
Keelen yes
Recovers from its own failures
Copilot no
Coding agent partial
Keelen yes
Learns across iterations
Copilot no
Coding agent partial
Keelen yes
Runs on your own model plan, at cost
Copilot no
Coding agent no
Keelen yes
Human gates per project (plan review · manual merge)
Copilot no
Coding agent partial
Keelen yes
Loop metrics: cycle time, verification pass rate, token burn
Copilot no
Coding agent no
Keelen yes

12 — Receipts

Keelen is built by Keelen.

This platform's own repository runs on the loop. The scheduler that dispatched last night's iterations was itself shipped by an iteration — planned by the PM layer, gated by the same red-first proof and adversarial review, merged by the same reconciler you get. We are the first customer, and the angriest.

The loop, right nowlive
– PRs merged this week– iterations in 24hfleet-wide · live

13 — Pricing

Flat tiers. Zero token markup.

Your AI usage bills to your own provider at cost — Keelen never resells tokens. The subscription pays for the loop: the scheduler, the isolated VMs, the gates, the dashboard, the recovery machinery. Cancel any time.

Indie
$29/ mo
For solo devs and side projects.
  • 200 iterations / month
  • 3 projects
  • 2 concurrent runs
  • 1 scheduled project
  • 30-day log retention
  • Email support
Start with Indie
most picked
Operator
$79/ mo
Ship while you sleep.
  • 1,000 iterations / month
  • 10 projects
  • 5 concurrent runs
  • 5 scheduled projects · 24/7 loop
  • 90-day log retention
  • Priority support
Go Operator
Agency
$299/ mo
For teams running multiple clients.
  • 5,000 iterations / month
  • 30 projects
  • 15 concurrent runs
  • Unlimited scheduled projects
  • 5 team seats
  • 1-year log retention
  • Dedicated support channel
Go Agency
Enterprise
For orgs with 10+ repos on the loop. — Unlimited projects + concurrent machines · SSO (Google, Okta, SAML) · Self-hosted runner option.
Talk to us

One iteration = one machine run — a PM planning pass or a dev run. Most tasks ship in one to three. At full use, Operator's 1,000 iterations work out to about $0.08 of platform fee per run.

Compare all plans →

14 — Straight answers

Asked a search box. Answered here.

The questions people type before they ever reach us. First paragraph is the whole answer — quote it.

What is Keelen?

Keelen is an autonomous coding loop: an AI development team that runs against your GitHub repository around the clock. It turns free-form requests into a prioritized roadmap, breaks roadmap items into dev-ready tasks with acceptance criteria, implements each task in an isolated single-use VM using your own Claude, Codex, GLM, or Kimi credentials, verifies every change through test and review gates, and ships the result as a merged pull request — or holds it for your review, if that's what you've configured.

Flat pricing from $29/month with zero token markup. When the loop is unsure, it stops and asks instead of guessing — and the live loop stats on this page are real (they deliberately undercount).

Can an AI safely merge code to main?

Only if it never grades its own homework. Keelen gates every AI-written pull request behind five checks: a red-first proof that new tests fail before the change and pass after, an adversarial review by an independent model, your own test suite on a clean checkout, a green CI run, and an optional human review window you control per project. A failing gate holds or reopens the work — it never merges.

The loop is also forbidden from weakening your checks: it may not skip a failing test or mark a check non-required to get to green.See the five gates →

Can I use the Claude, ChatGPT, GLM, or Kimi plan I already pay for?

Yes — Keelen is bring-your-own-key by design. Connect a Claude Pro or Max login (or Anthropic API key), a Codex login from your ChatGPT subscription (or OpenAI API key), a GLM (Z.ai) API key, or a Kimi K3 key from your Kimi Code membership (or Moonshot), and the loop schedules that engine against your roadmap around the clock. Keelen never resells tokens and adds zero markup: you pay a flat platform fee, and AI usage bills to your provider at cost.

Your subscription idles about 20 hours a day — Keelen puts it on the night shift.Put your Claude Max plan to work →

How much does Keelen cost?

Keelen is a flat monthly fee metered by iterations — one iteration is one machine run. Indie is $29/month for 200 iterations, Operator is $79/month for 1,000, and Agency is $299/month for 5,000 with 5 team seats; Enterprise is custom. Every tier is bring-your-own-key with zero token markup, so at full Operator use the platform fee is about $0.08 per run.

Add-on packs cover burst months, and every plan cancels anytime.Compare plans →

What does Keelen ship while you sleep?

The long tail your team never reaches: test coverage and red-first test fixes, refactors, dependency bumps, papercuts, and steady progress on roadmap features — each delivered as a separate pull request with acceptance criteria, so your morning review is a merge queue, not an archaeology dig. When a task needs a product decision, the loop doesn't guess: it pauses that task and asks you one plain-English question.

Budgeted retries and circuit breakers on every failure class — autonomy with brakes.

15 — FAQ

Reasonable doubts.

Things people ask in the first call. Email us if yours isn't here.

Which AI models does Keelen support?

Keelen is model-agnostic — bring your own key for any supported engine: Anthropic Claude (Opus and Sonnet, via Claude Code), OpenAI Codex (GPT-5.6), Zhipu GLM 5.2, and Moonshot Kimi K3 (via Claude Code on kimi.com). Pick an engine per project; token usage bills to your own provider account at cost, and you can switch engines without losing your roadmap or history.

Do I need a Claude Max plan?

No. Keelen runs on whatever credentials you connect at setup — a Claude subscription login or API key, a Codex login, a GLM key, or a Kimi key. We don't resell tokens; usage bills to your own provider at cost. If you do own a Claude Pro or Max plan, Keelen is the highest-leverage thing you can point it at: the loop runs on the subscription you already pay for.

How does it avoid wrecking my codebase?

Five gates stand between the AI and your main branch. New tests are applied without the implementation first and must fail — tests born green are rejected. An independent adversarial reviewer that shares no context with the dev run reviews the diff. Your real test suite runs on a clean checkout. Nothing merges over a red required CI check. And gated auto-merge waits out a review window — or you can replace it entirely with plan-review sign-off before any code is written, manual merge, or branch-only mode. The loop is also forbidden from weakening your checks: it may not skip a failing test or mark a check non-required to get to green.

What happens when it gets stuck?

Every failed run is classified into one of 30 failure kinds. Infrastructure blips and provider limits retry on a budget and never count against your work; real dead ends become one plain-English card in your Needs-you queue with a recommended action, and the project pauses instead of burning your quota. Iterations are wall-clock capped (about an hour for a dev run), so nothing spins forever. You resolve the card, hit resume, and the loop continues.

What languages and stacks does it support?

TypeScript and JavaScript (including Next.js and Vite web apps, which get preview-server QA with a headless browser), Python, Go, Rust, C/C++, Godot, and Roblox (Rojo/Luau with the Lune test runner). Monorepos are supported with per-package test targets. Repos with no tests at all can still onboard — Keelen runs with an honest no-test posture until its own PRs add a test suite.

What does Keelen see and store?

Your repo is cloned into an isolated single-use VM that is destroyed when the run ends — no persistent volume, so code and credentials on disk die with the machine. What persists on our side: iteration logs (with secrets automatically scrubbed), PR metadata, and timeline metrics. Your credentials are encrypted at rest under independently rotated keys and are deleted the moment you revoke them.

How is Keelen different from Copilot or a coding agent?

Copilots autocomplete while your hands are on the keyboard. Chat coding agents do one task per prompt and wait for the next one. Keelen runs a standing process: it holds your roadmap, picks its own next task, works around the clock, verifies every change through test and review gates, recovers from flaky CI and merge conflicts on its own, and accumulates lessons and steering rules that persist across runs — on your own AI subscription, at cost.

Is Keelen a loop or a graph-based agent workflow?

Both — the loop is the product, the graph is the machinery. Keelen is not one model in a while-loop: it runs parallel lanes (intake, planning, dev, review, recovery) routed by scheduler policy over durable Postgres state, with circuit breakers on every retry cycle and human checkpoints where you configure them. That is everything graph-based agent frameworks promise — branching, parallelism, checkpointed shared state, human-in-the-loop — running as a crash-safe control plane instead of an in-memory graph.

Can I keep a human in the loop?

Yes, per project. Require plan review — a product sign-off and/or a developer sign-off on every plan before any code is written. Set merge to manual and Keelen opens the PR but leaves the merge button to you. Or choose branch-only and it pushes branches without opening PRs at all. You can also pause one project or your whole fleet at any time, and revoke GitHub or model access in one click.

Can I use Keelen without the web dashboard?

Yes. Keelen ships a public MCP server at https://keelen.ai/mcp over streamable HTTP. Add it to Claude Code, Claude Desktop, Cursor, Windsurf, the Codex CLI, or any MCP client, and 29 tools let you sign up, create projects, submit requests, reorder the roadmap, check project status and resolve escalations from chat. Signup and email verification are themselves tools, so you connect before you have a key. A request submitted over MCP enters the same intake pipeline as one typed into the dashboard.

What counts as an iteration?

One iteration = one machine run — a PM planning pass or a dev run. Manual runs and scheduler-triggered runs count the same. Most tasks ship in one to three iterations. If you hit your monthly cap, new runs pause until your cycle renews — or top up instantly with an add-on pack from the billing dashboard.

Start in minutes

Let it run overnight.
See what's in your inbox.

Drop your email — we'll set you up. Connect your repo and let it run overnight. Free for 14 days, no credit card required.

no spam · cancel anytime