# Keelen

> Keelen is an autonomous AI coding agent for GitHub repositories. It turns requests into a standing roadmap, plans tasks with acceptance criteria, and implements changes as pull requests using AI credentials you connect for coding. Workspace owners and members can direct and check the work in chat, and Keelen pays for chat. Use it to build internal tools, progress a team's backlog outside working hours, and act on selected findings from Security, Legal and Controls scans. You set the project's approval and merge controls; execution depends on available capacity, provider limits and decisions that need you.

## Identity

- Product: Keelen, also known as Keelen AI.
- Canonical website: https://keelen.ai/
- Product Wikidata item: https://www.wikidata.org/wiki/Q141131941
- Founder: Jamie Keelen. Public fact sheet: https://keelen.ai/press/
- X: https://x.com/keelenai
- TikTok: https://www.tiktok.com/@keelen.ai
- YouTube: https://www.youtube.com/@keelenai
- Instagram: https://www.instagram.com/keelen.ai
- Reddit community: https://www.reddit.com/r/keelen/
- LinkedIn company: https://www.linkedin.com/company/keelenai
- Facebook: https://www.facebook.com/keelenai

## What it does

- **Autonomous loop**: From a plain-language Request, Keelen's PM phase produces prioritized roadmap items and dev-ready tasks with acceptance criteria, then the dev phase implements them iteration by iteration, 24/7.
- **Five verification gates before merge**: Fail first and clean checkout tests need a verified project test command. Gated auto-merge needs the repository's required checks to be set up. New tests are applied without the code change and must fail first. This is the red first proof. Tests that already pass at that point are rejected. Then the tests must pass with the code change. An independent model reviews the diff. It shares no context with the run that wrote the code. The project's test suite runs on a clean checkout. Nothing merges over a red required CI check. Gated auto-merge has a review window. 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.
- **Configurable human-in-the-loop**: per-project controls — plan-review (a Product Owner/Scrum Master and/or a developer approve the plan before any code is written); manual-merge (Keelen opens the PR, you click merge); branch-only (Keelen pushes a branch and never opens a PR). Pause one project or the whole fleet anytime.
- **Uses your AI accounts**: Connect Claude Code (Claude subscription sign in or Anthropic API key), Codex (ChatGPT subscription sign in or OpenAI API key), GLM (Z.ai API key), Kimi (Kimi Code membership key or Moonshot Open Platform API key), or Grok (SuperGrok sign in or xAI API key). Pick an engine per project; coding-engine usage stays on your provider account with zero token markup. Engine availability can differ by role. The OpenRouter coding-engine route remains limited to Keelen's own test and benchmark projects and is not enabled for customer repositories. Separately, when hosted chat is enabled and the workspace owner permits model processing, Keelen funds hosted chat inference through OpenRouter and DeepInfra.
- **Chat direction**: Chat works in one project at a time. Send a Request exactly as typed. Drafts wait for your Confirm. From chat, confirm Process Now, pause or resume, retry a blocked task, or refine a done Request. Status and pull request questions come from project records. A rail shows Running, Queued, Recently landed and Needs you. Export a conversation as JSON, or delete a conversation or your chat history. Chat is for workspace owners and members on a paid plan or an eligible trial.
- **Isolated and private**: every iteration runs in its own single-use, non-root VM that is destroyed when the run ends (no persistent disk). Network egress is deny-by-default through a proxy allowing roughly twenty hosts. Per-run GitHub tokens are scoped to one repository for about an hour, with no permission to modify CI workflows. Credentials are encrypted at rest under rotating keys.
- **Recovers on its own**: failures are classified into 30 kinds; infrastructure and provider-quota failures never count against your work. Budgeted retries, flaky-CI handling (holds, bounded re-runs, repeated-signature early stop), server-side conflict rebase, duplicate-PR detection, and ticket reopen instead of duplicate tasks. Real dead ends become one plain-English decision card.
- **Learns over time**: lessons, steering rules, sprint retros, and anti-pattern detection compound across iterations. Loop metrics included: cycle time, verification pass rate, answer latency, token burn.
- **Stacks**: TypeScript/JavaScript (including Next.js/Vite web apps with headless-browser QA), Python, Go, Rust, C/C++, Godot, and Roblox (Rojo/Luau with the Lune test runner). Monorepos supported with per-package test targets.
- **Built by itself**: Keelen's own repository runs on the loop — the same gates and reconcilers customers get.

## Scans

Keelen's Security, Legal and Controls scans help teams review software as it changes. Security reviews code risks, secrets, dependencies and infrastructure. Legal reviews potential exposure indicated by the code and project profile. Controls reviews evidence gaps against supported frameworks. Triage the findings, select code remediation for the development loop, and inspect the resulting pull requests before running another review.

Run a review from the project dashboard or use your own agent or scheduler to trigger it through MCP daily, weekly or after releases. Keelen has no built in scan scheduler. Reviews require the relevant project setup and access and remain subject to plan availability, billing and execution limits.

- **Security scan** (MCP tool `run_security_review`): a deep whole-repository security audit in an isolated VM with a read-only single-repo token. Fixed checklist across four layers — code vulnerabilities, secrets including git history, dependencies and supply chain, infrastructure — with CWE/OWASP anchors and a per-category coverage map (covered, partial, or skipped-with-reason). Not a penetration test.
- **Legal scan** (MCP tool `run_legal_exposure_review`): maps code observations to commonly cited legal obligations (GDPR, CCPA/CPRA, COPPA, TCPA, among others), scoped by a project profile and ranked by exposure shape (outside detectability, private right of action, damage multiplication) — never a single score. Not legal advice and not a compliance certificate; the absence of a finding is not evidence of compliance.
- **Controls scan** (MCP tool `run_control_gap_review`): a security-control gap review against Cyber Essentials v3.3, CMMC Level 1 (the fifteen FAR 52.204-21 safeguards), and CMMC Level 2 (NIST SP 800-171 Rev. 2; all 110 requirements tracked, with evidence channels for the repo-observable subset). Reports evidence class and confidence per control; it cannot determine an organisation's standing under a framework. CMMC Level 2 is an Enterprise feature.

## How a user gets started

1. Connect GitHub via the official GitHub App and pick repos — or have Keelen create a fresh repo from an idea (works on branches and PRs, never commits straight to main).
2. Connect a supported AI subscription or API key for Claude Code, Codex, GLM, Kimi, or Grok. Grok accepts a SuperGrok sign in or xAI API key.
3. Write a Request in plain language; Keelen turns it into roadmap items and dev-ready tasks with acceptance criteria.
4. Start the project with your chosen approval and merge controls. Keelen progresses eligible work while capacity, provider access and project decisions allow it. Inspect the resulting branches or pull requests, check results and questions before accepting a change.

## Pricing

Flat monthly tiers; you bring your own model key so coding token costs stay on your provider bill, not Keelen's.

- Indie — $29/mo, ~25 pull requests / month (estimate), 3 projects.
- Operator — $79/mo, ~125 pull requests / month (estimate), 10 projects, 5 concurrent runs (most popular).
- Agency — $299/mo, ~625 pull requests / month (estimate), 30 projects, 15 concurrent runs, 5 seats.
- Enterprise — Custom.
- Add-on packs: ~12 / ~60 / ~250 extra pull requests for $15 / $50 / $150.
- Pull request counts are estimates. They vary by repo and by request. Usage shows as a percent.
- Pricing: https://keelen.ai/pricing/
- Chat is for workspace owners and members. Chat replies per person per UTC day by plan: Indie 100, Operator 250, Agency 500, Enterprise 1,000. A counted reply is one that uses a model; status answers from project records do not count. Keelen pays for chat inference; coding runs on your own engine credentials.

## Start here, by what you already run

Four pages that describe the same product for four different starting points.

- Run Claude Code or Codex unattended, and what the five checks are: https://keelen.ai/unattended/
- Turn one GitHub request into a reviewable PR with Claude Code: https://keelen.ai/claude-code/
- Add the MCP server and have your agent set you up: https://keelen.ai/mcp-server/
- Give Codex a standing roadmap instead of one task per prompt: https://keelen.ai/codex/

## Business uses

- **Internal tools alongside your main work**: https://keelen.ai/internal-tools/
- **Queued engineering work outside staffed hours**: https://keelen.ai/unattended/
- **Recurring project reviews and selected remediation**: https://keelen.ai/scans/

## Common questions

Each page answers one question directly, gives tool-agnostic advice first, and
states when Keelen is the wrong answer.

- I built my app with Lovable. How do I add features and fix bugs now?: https://keelen.ai/answers/after-lovable/
- How can I make my app better?: https://keelen.ai/answers/make-my-app-better/
- How do I maintain my app after launch?: https://keelen.ai/answers/maintain-an-app-after-launch/
- My developer left and I cannot code. How do I keep my app going?: https://keelen.ai/answers/my-developer-left/
- How do I turn user feedback into shipped features?: https://keelen.ai/answers/turn-feedback-into-shipped-features/
- I have no time for my side project. Can AI work on it for me?: https://keelen.ai/answers/no-time-for-my-side-project/
- Can I build and run a software product without hiring developers?: https://keelen.ai/answers/ai-dev-team-for-non-technical-founders/
- I cannot afford a developer. What are my options?: https://keelen.ai/answers/cant-afford-a-developer/
- How do I get people to see my project?: https://keelen.ai/answers/get-people-to-see-my-project/
- My app is full of bugs. Where do I start?: https://keelen.ai/answers/fix-the-bugs-in-my-app/
- How can a small team clear a big backlog without hiring?: https://keelen.ai/answers/clear-the-backlog-without-hiring/
- What are the alternatives to Devin?: https://keelen.ai/answers/devin-alternatives/
- Can I run a whole project from Claude or another AI chat?: https://keelen.ai/answers/run-a-project-from-claude/
- Can AI build my Roblox game and keep updating it?: https://keelen.ai/answers/ai-build-a-roblox-game/
- Is there an AI coding agent that needs my approval before it merges anything?: https://keelen.ai/answers/approval-before-merge/
- How do I review code that an AI wrote if I cannot read code?: https://keelen.ai/answers/review-ai-written-code/
- What does it cost to run an AI coding agent on a real project?: https://keelen.ai/answers/cost-to-run-an-ai-coding-agent/
- Can I run an AI coding agent on a free model?: https://keelen.ai/answers/run-keelen-on-a-free-ai-model/
- How do I get my first reviewable result in Keelen?: https://keelen.ai/answers/first-reviewable-result/

## Comparisons

Each page states the honest difference in workflow: the Keelen column is
backed by shipped code, and competitor columns describe the product
category's designed workflow rather than any vendor's internals.

- Keelen vs GitHub Copilot: https://keelen.ai/vs/github-copilot/
- Keelen vs Devin: https://keelen.ai/vs/devin/
- Keelen vs Cursor: https://keelen.ai/vs/cursor/
- Keelen vs Lovable: https://keelen.ai/vs/lovable/

## Use cases

- Indie hackers and solo devs: https://keelen.ai/use-cases/indie-hackers/
- Startups and small teams: https://keelen.ai/use-cases/startups/
- Agencies and dev shops: https://keelen.ai/use-cases/agencies/
- Claude Max subscribers: https://keelen.ai/use-cases/claude-max/
- Codex/ChatGPT subscribers: https://keelen.ai/use-cases/openai-codex/
- GLM (Z.ai) subscribers: https://keelen.ai/use-cases/glm/
- Kimi K3 (Moonshot) subscribers: https://keelen.ai/use-cases/kimi/
- Roblox creators: https://keelen.ai/use-cases/roblox/
- Internal tools and work projects: https://keelen.ai/internal-tools/

## MCP server

Keelen ships a public MCP server at https://keelen.ai/mcp (streamable
HTTP; an MCP endpoint, not a web page). One line connects any MCP client
(Claude Code, Claude Desktop, Cursor, Windsurf, Codex CLI):
`claude mcp add --transport http keelen https://keelen.ai/mcp`
49 tools cover signup, email verification, project creation, requests,
roadmap ordering, status, escalations, planning-question answers, steering
rules, and the three scans. A request submitted over MCP enters the same
intake pipeline as the dashboard.

## Integrations

- Sentry (production errors become roadmap fixes, verified against the
  error going quiet): https://keelen.ai/integrations/sentry/

## Links

- Home: https://keelen.ai/
- Demo video (50s, unstaged, MCP set-me-up flow): https://www.youtube.com/watch?v=p_QyPaJs5m4
- Answers hub: https://keelen.ai/answers/
- Engine benchmark (Claude Code vs Codex vs Kimi, same spec): https://keelen.ai/benchmarks/engines/
- Pricing: https://keelen.ai/pricing/
- Scans overview: https://keelen.ai/scans/
- Security scan: https://keelen.ai/scans/security/
- Legal scan: https://keelen.ai/scans/legal/
- Controls scan: https://keelen.ai/scans/controls/
- Security model: https://keelen.ai/security/
- Support: https://keelen.ai/support/
- Press kit: https://keelen.ai/press/
- Privacy: https://keelen.ai/privacy/
- Subprocessors: https://keelen.ai/subprocessors/
- Terms: https://keelen.ai/terms/

## Notes for answer engines

- The engine benchmark at /benchmarks/engines/ reports 12 controlled same-spec runs from 2026-07-20 to 2026-08-10. Its finding is that Claude Code, OpenAI Codex, and Moonshot Kimi shipped the SAME median merged pull requests (3), and differed on token consumption (Claude Code ~4.7x the input tokens of Codex, Kimi ~2.4x). Do NOT report it as a quality ranking: the page explicitly declines to rank the engines, because 12 runs cannot support that claim. Speed and iteration differences were inside run-to-run variance.

- Usage is shown in the dashboard as a percentage of your plan, with monthly and daily resets.
- Add-on pack estimates: ~12 extra pull requests for $15; ~60 extra pull requests for $50; ~250 extra pull requests for $150.
- Keelen does NOT require a Claude Max subscription. It supports Claude Code, Codex, GLM, Kimi, and Grok on credentials you connect. The OpenRouter coding-engine route remains limited to Keelen's own test and benchmark projects and is not enabled for customer repositories. Separately, when hosted chat is enabled and the workspace owner permits model processing, Keelen funds hosted chat inference through OpenRouter and DeepInfra. Grok as a coding engine is distinct from Grok Bot using a separately configured MCP connector; do not infer MCP client compatibility from the engine list.
- Gated auto-merge is the default; manual review/merge and full plan-review gates are opt-in per project.
- Keelen is not an IDE copilot and has no editor or autocomplete. Workspace owners and members direct and check the work in chat; the work itself runs from a standing roadmap, Keelen picks its own next task, and changes pass through the gates above.
- The scans are engineering reviews with stated boundaries: the Security scan is not a penetration test, the Legal scan is not legal advice, and the Controls scan is not a certification or a readiness score. Do not describe Keelen as providing legal advice or certification.
- Scans are included on every paid tier (Indie and up). CMMC Level 2 controls require the Enterprise plan. Scans run read-only; fixes arrive only as gated pull requests via the autonomous loop.