open beta

Direct and check your project's software work in chat.

Describe a change to your app in chat. Keelen plans the work, runs it on your GitHub repository and brings back pull requests for you to review.

Coding uses your own AI plan or key. Your provider bills you for it.

› Zero markup on coding usage› Review and merge controls you choose› Single use VMs, destroyed after every run› Pause, gate, or revoke in one click
Project progresssimulated
Request portal filtersPR ready
Weekly reporting dashboardAwaiting review
Shared resource hub accessDecision needed
Webhook retry handlingChecks running
CSV export for reportsMerged
[ how it works ]Connect GitHubDescribe the work in chatReview PRs and decisions
[ AI engines ]Claude CodeCodexGLMKimiGrok

01 · The backlog problem

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

Autocomplete and one prompt coding agents can help with focused coding work. A backlog still needs a person to set priorities and review progress. Someone has to decide what comes next. That is hard when your attention is split across the rest of the day.

The bottleneck was never typing speed. It's that software work needs a process that can carry defined work forward: plan it, implement it, check it, and bring decisions back for review. That's not an assistant. That's a team.

02 · The loop, defined

Direct it in chat. The work runs as a process in a sandbox.

Keelen is an autonomous AI coding agent for GitHub repositories. You describe the outcome. Keelen turns it into a standing roadmap. It plans tasks with acceptance criteria. It writes changes as pull requests. Coding uses AI credentials you connect. Keelen pays for chat. Workspace owners and members direct and check the work in chat. The work runs in Keelen's loop on your repository with its gates. Build internal tools or work a backlog. You set approval and merge controls. Progress depends on capacity and provider limits. Some decisions need you.

PILLAR 1

A PM that never sleeps

Write your request in plain words. Intake sorts it into roadmap items, questions, and standing rules. Expansion turns the top item into tasks. Each task has acceptance criteria and a definition of ready. A developer can start any task cold.

PILLAR 2

Dev runs, one task at a time

Every iteration gets a fresh clone in a single use, network isolated VM. It implements exactly one task and opens a pull request. Each unit stays small. You can review it, and you can revert it. That is how 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.

Your project setup decides which controls you get. A verified test command turns on test proof. Configured required checks protect the merge.

plancode① red first② review③ tests④ CI⑤ windoweligible to merge

Red first proof

This gate needs a verified project test command. New tests go in first, without the implementation, and they must fail. Then the implementation lands, and the same tests must pass. A test that starts green is rejected, so the proof can still catch a regression.

Adversarial review

A separate adversarial review reads the diff on its own. It never shares the context from the development run. The review model depends on your project setup. A rejection holds the work for a fix.

Your tests, actually run

This gate needs a verified project test command. Keelen checks out the PR head clean, then runs that command. Monorepos work. The timeout comes from your project's own baseline.

CI green merge gate

Required checks stop a merge when a result is red. If a test check fails, the work is held and the task reopens. If an integration check is flaky, it gets a bounded rerun.

The review window

This gate applies when gated auto-merge is set up, and it waits out a review window first. You can also drop auto-merge and use plan review sign off. Then a person approves the plan before any code is written. Or keep the merge button for yourself.

Test checks have limits

When the guards are on and can check the change, they block detected assertion removal or weakening within their supported scope. Supported exceptions can let those changes through. A declared exception does not prove a human approved it. The guards can be turned off. Missing inputs can make them skip the check. They do not catch every way a test can lose meaning. The tests and code still need human review.

04 · Built for bad nights

Autonomy is easy when everything works. Keelen is built for when it does not.

It knows why it failed

Every failed run gets one of 30 failure kinds. Infra blips and provider limits do not count against your work. Deterministic failures get their own recovery budgets. Each one has a cap.

It retries like an adult

Retries are budgeted for each failure class, with exponential backoff. A provider quota hit? Keelen waits for the reset. Then it resumes on its own.

It doesn't spam your board

A post merge failure reopens the original ticket. No duplicate is forked. Conflicts are healed on the server 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 reruns. 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 a root cause fix ticket first. Quarantine is a last resort, and it is tracked. A deterministic failure is never quarantined.

It knows when to stop

Circuit breakers watch every runaway pattern. They 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 stay within configured access.

Connecting GitHub and your model key takes one click each. 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 own app, and you pick the repos Keelen can see. Each run then gets its own token. That token works on one repo only and lasts about an hour. It cannot touch your CI workflows. When the run ends, the token is already dying.

B

Keys encrypted and redacted

Your model key is encrypted when you connect it. Each credential type gets its own key, and those keys rotate. Keelen also strips connected credential values from its logs.

C

A VM that exists for one job, then vanishes

Each iteration runs in its own isolated VM. That VM has no persistent disk. Credentials reach it only while the run is live, and 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 goes through a proxy. That proxy denies by default. It allows about twenty hosts. Those are your AI provider, GitHub and package registries. It logs each request, even 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. In PR modes, development work is recorded as a pull request; branch-only mode pushes a branch without opening one. 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 · Scans

The loop that ships your code can audit it, too.

As your software changes, review its risks. Check security, possible legal exposure and gaps in controls evidence. Run a scan from the dashboard. You can also use your own agent or scheduler to trigger repeat scans through MCP. Triage the findings. Send the code work you pick into the roadmap. Review the pull requests that come back before you rescan.

Your own scheduler sets the repeat timing. Keelen has no built in scan scheduler. The scans come with every paid plan. Runs are read only. You pick fixes, and they arrive as normal gated pull requests. All three scans →

07 · 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 pull requests; it never commits straight to main.

● acme/internal-tools · main
02

Connect your engine

Choose Claude Code, Codex, GLM, Kimi, or Grok. Connect a supported subscription or API key. Grok accepts SuperGrok sign in or an xAI API key. Credentials are encrypted at rest, and coding usage stays on your provider account with no token markup. Keelen pays for chat.

● engine · your account · ✓ ready
03

Write a request

Keelen turns your request into prioritized roadmap items and tasks. Each task gets acceptance criteria. It asks when the request is unclear. You write plain English, like “Build a client approval portal.”

● T-088 · P0 · Add client approvals
04

Press play

The loop picks the top task and starts work. Follow its progress live, or return to review pull requests and answer questions when Keelen needs your input.

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

08 · Bring your agent

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

Keelen ships an MCP server. Point your coding agent at it. Then it can sign up, create projects, file requests, reorder the roadmap and clear blockers. Connecting GitHub or an AI provider can still require that provider's approval flow.

Claude Code MCP setup demo · August 2026 · 50 seconds

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.

43 tools

Create a project. Send a request. Reorder your roadmap. Check its status. Resolve escalations. Start a security review.

One pipeline

A request sent over MCP uses the same intake path as the dashboard. Same queue, same planner, same gates.

Signing up, connecting GitHub and creating a project are free. Running the loop needs an active trial or paid subscription. Provider costs are separate.

09 · Progress and decisions

Keep control of the work.

Keelen plans work and opens pull requests in the background. Review the results. Answer questions when a task needs a decision. Your approval and merge settings decide what can happen next.

example/operations-hub›todaysimulated
working in the background
pull requests · today2 merged
Add request status filters
T-088 · PR ready for review
Export weekly reporting data
T-090 · merged · after review
Fix retry handling for sync jobs
T-091 · PR open · checks running
Add search to shared resources
T-092 · merged · after review
needs you · 1 decision
T-093
Who can approve requests in this portal?
Team leads
Named approvers
ready for review1
waiting on you1
checks running1
merged after review2

10 · 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 and it runs in the next iteration.
  • Curated memory means Keelen learns from each iteration. It keeps what is still true and drops the rest.
  • Blocker detection flags you after three failed iters on the same line.
  • You can pause and resume at any iteration boundary. The machine stops within a tick.
simulated

Next

2
T-091feature
Add filters to the request portal
P10/7
T-098improvement
Retry failed webhook deliveries
P10/4

In progress

1
T-088feature
Build the weekly reporting view
P04/6

Blocked

1
T-082chore
Choose who can access the resource hub
P12/5

Done

2
T-079feature
Export request history as CSV
P25/5
T-076improvement
Fix duplicate sync jobs
P14/4

11 · Who it's for

Built for the people whose roadmap outruns their hands.

Indie devs & side projects

Bring defined feature work from the project you keep coming back to. Keelen rebuilds the context and plans the work. It leaves reviewable pull requests and decisions for when you return.

Start with Indie →

Internal tools at work

Build the reporting tool, shared resource hub, or integration your colleagues need. Your main job keeps moving. You review the pull requests. Then you deploy the tool through your company's deployment process.

See Keelen at work →

Founders & small teams

Queue well defined fixes, tests and small features for evenings, weekends or holidays. When you return, review the pull requests. Then review the decisions. Each project has its own approval and merge controls.

See the team handoff →

Agencies

Fifteen concurrent machines across thirty client repos. Each project keeps its own merge policy and its own story. One console, and one flat bill.

Go Agency →

12 · Compare a real setup

Compare the workflow, controls, and evidence.

Use this checklist to compare a real repo setup. Then read what a named provider does today. Check its own docs before you pick the controls for a bounded Request.

Start with a Request

Keelen records a Request. The roadmap then prepares eligible work. Read the Request and its criteria first. Do not treat it as a commitment yet.

Reuse a supported provider setup

Connect a supported subscription or API key. Your provider plan sets what is available. It sets the allowance and the limits. It sets the billing.

Make test proof concrete

Red first proof and clean checkout runs need a verified project test command. A repo without one must set that up first. Then it can give that evidence.

Configure merge protection

Required checks protect a merge only when the repository is set up for them. Project settings can use plan review. They can also use manual merge or branch-only work.

Read the receipt

A useful comparison ends with the revision and the check results. It also ends with the human call still open. Token or pull request counts do not show quality. They do not show billed cost either.

Compare specific workflows: GitHub Copilot · Devin · Cursor · Lovable

13 · Receipts

Keelen is built by Keelen.

Keelen's own repo is a dogfood example. Its commits and CI logs show how the team runs the workflow it builds. That is evidence from that repo. It is not independent customer proof. It does not promise a customer outcome.

14 · Pricing

Flat tiers. Zero token markup.

Your coding usage bills to your own provider at cost. Keelen adds no markup on tokens. The plan fee pays for the loop. That covers the scheduler, the isolated VMs, the gates, the dashboard and the recovery machinery. Keelen pays for chat. 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
  • Security, legal + controls scans
  • Email support
  • Up to 100 chat replies a day
Start with Indie
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
  • Security, legal + controls scans
  • Priority support
  • Up to 250 chat replies a day
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
  • Security, legal + controls scans
  • Dedicated support channel
  • Up to 500 chat replies a day
Go Agency
Enterprise
For orgs with 10+ repos on the loop. Unlimited projects + concurrent machines · SSO (Google, Okta, SAML) · Self hosted runner option.
Up to 1,000 chat replies a day.
Talk to us

Chat replies count replies that use a model, per person, per UTC day. Chat is for workspace owners and members.

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

Compare all plans →

15 · Straight answers

Questions about handing over software work.

Short answers about internal tools and ongoing work. They also cover the reviews and controls you keep.

All answers →

What is Keelen?

Keelen is an autonomous AI coding agent for GitHub repositories. You describe the outcome. Keelen turns it into a standing roadmap. It plans tasks with acceptance criteria. It writes changes as pull requests. Coding uses AI credentials you connect. Keelen pays for chat. Workspace owners and members direct and check the work in chat. The work runs in Keelen's loop on your repository with its gates. Build internal tools or work a backlog. You set approval and merge controls. Progress depends on capacity and provider limits. Some decisions need you.

Flat pricing from $29/month with zero token markup on coding. When the loop is unsure, it stops and asks instead of guessing.

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. New tests must fail before the change and pass after. That holds where a verified project test command supports it. A separate context runs an adversarial review. Your test suite runs on a clean checkout when a verified command is available. Configured required checks must pass. An optional human review window comes last. You control it per project. A failing gate holds or reopens the work until the conditions are met.

When the guards are on and can check the change, they block detected assertion removal or weakening within their supported scope. Supported exceptions can let those changes through. A declared exception does not prove a human approved it. The guards can be turned off. Missing inputs can make them skip the check. They do not catch every way a test can lose meaning. The tests and code still need human review.See the five gates →

Can I use an AI subscription or API key I already have?

Yes. Connect a Claude Pro or Max login, or an Anthropic API key. Connect a Codex login from your ChatGPT subscription, or an OpenAI API key. You can also use a GLM (Z.ai) API key, a Kimi Code or Moonshot API key, or a SuperGrok sign in or xAI API key for Grok. Keelen codes with that engine within your provider limits. You pay a flat fee, with no token markup. Coding usage bills to your provider at cost. Keelen pays for chat.

Point a subscription or API key you already have at a defined piece of work. Then return to review the result.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 costs $29/month for 200 iterations, and Operator costs $79/month for 1,000. Agency costs $299/month for 5,000, with 5 team seats. Enterprise pricing is custom. Every tier codes with your own key, with zero token markup. Keelen pays for chat. 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?

Keelen can work through defined fixes, tests and small features while your team is offline. That covers nights, weekends and holidays. The work follows your project's approval and merge settings. With manual merge, you come back to pull requests and check results to review. Quotas, failed checks, missing dependencies and questions for you can all limit progress. So a queued backlog is not a promise of a set number of finished tasks.

Start with one bounded task and leave room to review the result.The team handoff →

Can I build internal tools alongside my main job?

Yes. You need a GitHub repository and a supported AI provider that fit your company's policies. Describe the tool and its acceptance criteria. Then Keelen plans the work. It implements the work as pull requests. You review the changes and answer questions. Hosting, colleague sign in and access rules belong to the software you build. They also belong to the deployment you choose.

For a first task, try a small integration. A reporting dashboard or a resource hub also works.Internal tools at work →

Can I repeat security, legal and controls scans?

Yes. Run the scans from the dashboard. Or have your own agent or scheduler call Keelen's MCP tools daily, weekly or after a release. Keelen has no built in scan scheduler. Reviews produce findings and evidence for triage. Selected code fixes can enter the development loop. Legal reviews are not legal advice. Controls reviews do not certify compliance.

Scan availability, setup, billing and execution limits still apply.How recurring reviews work →

Can Keelen fix my Sentry errors automatically?

Yes. Connect your Sentry project. New production errors then file onto your roadmap. They are filtered for noise, capped by a daily budget and ranked fatal first. The loop plans the fix and implements it in an isolated VM on your own AI credentials. It passes the test and review gates, then opens a pull request. Keelen then polls your Sentry until the error goes quiet. Only then does it call the error fixed.

Budgets default to 5 filings a day per project with 3 fixes in flight per project. A bad deploy costs you database rows instead of AI spend.Sentry integration →

16 · FAQ

Reasonable doubts.

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

What can I do in Keelen's chat?

Chat works in one project at a time. Send a Request exactly as you typed it. Drafts need your Confirm. From chat you can confirm Process Now, pause or resume, retry a blocked task, and refine a done Request. Status and pull request questions answer from project records. A rail shows Running, Queued, Recently landed and Needs you. Export a conversation as JSON, delete it, or delete chat history. Keelen pays for chat inference; coding uses your own engine. Chat is for workspace owners and members on a paid plan or an eligible trial.

Which AI engines can I connect?

Connect Claude Code, OpenAI Codex, GLM, Kimi or Grok. Use your own supported subscription or API key. Grok accepts a SuperGrok sign in or an xAI API key. Pick an engine for each project. Coding-engine use stays on your provider account. If you switch engines, your roadmap and history stay. Engine availability can differ by role. The OpenRouter coding-engine route stays limited to Keelen's own test and benchmark projects. It is off for customer repos. Separately, when hosted chat is on, Keelen pays for that inference through OpenRouter and DeepInfra.

Do I need a Claude Max plan?

No. Keelen runs on whatever credentials you connect at setup. That can be a Claude subscription login or API key, a Codex login or OpenAI API key, a GLM key, a Kimi key, or a SuperGrok sign in or xAI API key. We don't resell tokens. Coding usage bills to your own provider at cost. Keelen pays for chat. If you do own a Claude Pro or Max plan, Keelen puts it to work. 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. Where a verified project test command supports it, new tests are applied without the implementation first and must fail. Tests born green are rejected. An independent adversarial reviewer reviews the diff. That reviewer shares no context with the dev run. When a verified project test command is available, your test suite runs on a clean checkout. Configured required CI checks protect a merge from a red result. Gated auto-merge has a review window. Manual merge means Keelen opens the PR and you click merge. Branch only mode produces a branch with no PR. Plan review is a separate opt in. When it is on, a human approves the plan before any code is written. When the guards are on and can check the change, they block detected assertion removal or weakening within their supported scope. Supported exceptions can let those changes through. A declared exception does not prove a human approved it. The guards can be turned off. Missing inputs can make them skip the check. They do not catch every way a test can lose meaning. The tests and code still need human review.

What happens when it gets stuck?

Every failed run is sorted into one of 30 failure kinds. Infrastructure blips and provider limits retry on a budget. They never count against your work. A real dead end becomes one plain English card in your Needs-you queue, with a recommended action. The project pauses instead of burning your quota. Iterations are also capped by wall clock time, about an hour for a dev run. Nothing spins forever. You resolve the card, hit resume, and the loop continues.

What languages and stacks does it support?

Keelen supports TypeScript and JavaScript, including Next.js and Vite web apps. Those web apps get preview server QA with a headless browser. It also supports Python, Go, Rust, C/C++, Godot, and Roblox with Rojo/Luau and the Lune test runner. Monorepos are supported, with test targets per package. A repo with no tests at all can still onboard. Keelen runs with an honest no test posture until its own pull requests add a test suite.

What does Keelen see and store?

Your repo is cloned into an isolated single use VM. That VM is destroyed when the run ends. There is no persistent volume. Code and credentials on disk die with the machine. Some things do persist on our side. We keep iteration logs. Secrets in them are scrubbed automatically. We also keep PR metadata and timeline metrics. Your credentials are encrypted at rest. The keys rotate independently 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, then wait for the next one. Keelen runs a standing process. It holds your roadmap and picks its own next task. It works around the clock. Every change passes through test and review gates. It recovers from flaky CI and merge conflicts on its own. It also collects lessons and steering rules that persist across runs. You direct and check that work in chat. Chat adds no editor and no autocomplete. Coding runs on your own AI subscription, at cost. Keelen pays for chat inference. Chat is for workspace owners and members.

Is Keelen a loop or a graph based agent workflow?

Both. The loop is the product and the graph is the machinery. Keelen is not one model in a while loop. It runs parallel lanes. They cover intake, planning, dev, review and recovery. Scheduler policy routes them over durable Postgres state. Circuit breakers sit on every retry cycle. Human checkpoints sit where you configure them. That covers what graph based agent frameworks promise. It gives you branching, parallelism, checkpointed shared state and a human in the loop. Keelen runs all of that 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, which is 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. From chat, 43 tools let you sign up and create projects. They also submit requests, reorder the roadmap, check project status and resolve escalations. Signup and email verification are tools too. So you can connect before you have a key. A request sent over MCP enters the same intake pipeline as one typed into the dashboard.

What counts as an iteration?

One iteration is one machine run. That can be a PM planning pass or a dev run. Manual runs and scheduler triggered runs count the same. 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.

Can Keelen audit my code for security issues?

Yes. The Security scan is a deep whole repository audit. It runs in an isolated VM with a read only single repo token. It works a fixed checklist. It covers code, secrets (including git history), dependencies and infrastructure. You get ranked findings plus a coverage map with no silent gaps. Any finding can be sent to the loop. The loop fixes it and ships a tested pull request. The scan is included on every paid plan.

Does Keelen help with compliance frameworks like Cyber Essentials or CMMC?

The Controls scan reviews your repository. It looks for per control evidence. It checks Cyber Essentials v3.3, CMMC Level 1 and CMMC Level 2 (NIST SP 800-171 Rev. 2). The Legal scan maps code observations. It points to commonly cited obligations. Those include GDPR, CCPA/CPRA, COPPA and TCPA. Both are honestly bounded engineering reviews. They are not certifications. They are not legal advice. Both can route code fixable gaps into the loop as tested pull requests.

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