A full software factory, with the team ready to go.
Open a repository and you have a PM, a designer, a principal engineer, a reviewer, security, reliability and QA.
Every request runs through them, on your own Claude Code or Codex, and you review one result.
Desktop app for macOS and Windows. Parallel lanes on their own branches. Your checks after every turn.
Free. Open source. Always.
Used daily by engineers at Oya.ai and Jumpermedia.co.
Sponsored by OyaBrowser.com.
Download for macOS · Download for Windows · Watch the demo · Why switch · Get started · Roadmap · Share kit
Claude Code writes excellent code. But one agent in a terminal is one engineer with nobody around them:
- Nobody asks whether it's worth building, or what the smallest version is.
- Nobody designs it first, so the plan is whatever the agent typed first.
- Nobody reviews it. The agent grades its own work and says the tests passed.
- Nobody tries to break it before you do.
- And you can't see any of it: the changes are buried in scrollback, two agents at once wreck one working tree, and approvals roll past.
Keel is the whole factory, staffed. Every project comes with seven agents and the lifecycle that runs them: pm decides build, change, cut or not yet; designer owns what people see; principal designs the change; the main agent builds it; reviewer, security and reliability read the diff; qa runs the real thing. Nothing to hire, configure or prompt. Open a repository, add the team in one click, and ask for a feature.
And the factory floor is built in. Each request is a lane on its own branch and worktree. Every turn becomes one reviewable record: the files, the commands with their output, your project's real gate, the duration and the cost. Commands that need permission stop and ask in the conversation.
Your existing Claude sessions come with you. Running one in your terminal right now? Follow it live in Keel.
| Experience | Raw CLI / VS Code Extension | Keel |
|---|---|---|
| The team | One agent that plans, builds and grades its own work | Seven agents, ready to go: pm, designer, principal, reviewer, security, reliability and qa on every request |
| Reviewing code | git diff after the turn, scrolling through terminal logs |
Live stacked diffs with syntax highlighting as files are written |
| Multi-agent concurrency | One shared branch; simultaneous tasks collide and clobber files | Isolated Git worktrees (.keel/worktrees/) on dedicated task branches |
| Background jobs | Dev servers (pnpm dev) killed on turn exit |
Monitors: daemon supervises background jobs with streaming logs & Stop button |
| Command approvals | Prompts lost in scrollback; all-or-nothing permission flags | Inline approval cards: Allow Once, Allow Session, or 1-click Trust this project |
| Verification | Trusting the agent's prose or running checks by hand | Automatic gates: Keel runs your real make check, cargo test, or pnpm test |
| Existing history | Locked inside terminal history; no unified view | Replay & Follow: browse past sessions and watch external runs in real time |
| UI verification | Guessing files, accidental component duplication | Preview & change check: pick elements, send them to the agent, and see whether they actually changed |
| Speed & ergonomics | One terminal pane per agent, one project per window | Light desktop shell: Tauri + React over a local Rust daemon. No Electron, no bundled Chromium |
Watch three tasks progress concurrently across isolated Git branches, with live diffs and gate verification:
An agent alone writes code. A team decides what's worth building, designs it, reviews it, and tries to break it. Keel ships seven subagents and the lifecycle that runs them, written into .claude/agents/ and CLAUDE.md, so they work in Claude Code anywhere and not just in Keel:
| Stage | Agent | Returns |
|---|---|---|
| 1 | pm | Build, change, cut, or not yet, plus the smallest version worth shipping |
| 2 | designer | States, layout, and copy for anything a person will see |
| 3 | principal | The technical design: modules touched, invariants at risk, tests that pin it |
| 4 | implementation | The main agent writes it, in view, until the gate is green |
| 5 | reviewer, security, reliability | Only what is actually wrong with the diff |
| 6 | qa | Runs the real thing and reports what broke, with steps to reproduce it |
That screenshot is a real run on one request, "add discount codes". The pm chose build and skipped the designer because nothing visible changed. The principal designed it, and the gate passed with 11 tests. The reviewer then found a real bug the main agent had missed: a non-string code made the error itself throw. It was fixed and the gate re-run before qa tried to break it. QA came back with three open edge cases and one decision for the person.
New projects start with the team. For an existing repository, Add the team in Readiness writes it in, and never over a file you already have.
An agent reporting "done" is an assertion. Keel collects every file written, every command with its raw output, the repository's real gate verdict, commit hash, duration, tokens, and cost into one inspectable packet.
- Parallel work, separate branches. Every task lane can spin up its own Git worktree under
.keel/worktrees/<lane>on branchkeel/<lane>. Keep several projects open in one window, each with its own lanes. - Checks you recognize. Keel detects your project's gate (
make check,cargo test,npm test,pytest) and runs it after every turn. No invented green checkmarks. - Rewind with safe undo. Restore a pre-turn snapshot without blowing away your staged changes. Conflicting ignored files halt the operation safely.
When the agent needs permission to run a command, it stops right above your composer with the exact command line and intent.
-
Allow once runs the single invocation and remembers nothing.
-
Session & project rules grant scoped patterns under More options.
-
Trust this project eliminates repetitive permission tolls for repos you own. Visible in the status bar, withdrawable anytime.
-
Chat or terminal, per lane. Read a lane as formatted chat, or switch it to the agent's own interactive CLI. Lanes run
claudeorcodex.
You don't have to start a session in Keel to see it in Keel.
- Zero-migration history. Browse and replay past Claude Code conversations directly from
~/.claude/projects/—no import scripts or cloud accounts needed. - Follow work in real time. Launch
claudein your terminal, VS Code, or Orca. Keel's watcher picks up the active transcript and streams messages, tool calls, and diffs live. - Deep write recovery. Recovers files written not just by
Edit/Write, but by subagents (Task) and shell commands (cat >>, python heredocs), flagging edits outside the repo.
In the Claude Code CLI, background processes (run_in_background) get terminated the moment the turn completes. Keel's daemon takes them over:
- Monitors panel: Long-running processes like
pnpm devorgh run watchrun supervised outside turn lifetimes. - Live streaming output: Inspect stdout/stderr in real time and stop jobs with a single click.
- Automatic completion turn: When a background job finishes, its status arrives back into your conversation as a clean turn report.
Building frontends with agents often results in edited-the-wrong-file or duplicated-component bugs:
- Point-and-click inspection: Pick elements in the Preview tab, pin a note to each, and send them to the agent as one prompt with unique selectors and ranked source candidates.
- Change verification: Each pinned element's markup, computed style, and size are fingerprinted before and after the turn. If nothing changed, Keel says the edit probably went to the wrong file.
Never take your hands off the keyboard. Press ⌘K to search actions, files, and conversations, and ⌘/ to see every shortcut. On Windows, ⌘ is Ctrl.
| Shortcut | Action | Shortcut | Action |
|---|---|---|---|
⌘K |
Command palette | ⌘L |
Focus composer |
⌘N |
New lane | ⌘⇧N |
New lane on its own branch |
⌘1–⌘9 |
Go to lane 1–9 | ⌥↓ / ⌥↑ |
Next / previous lane |
⌘⇧M |
Merge lane | ⌘W |
Close lane |
⌘⇧A |
Allow oldest request once | ⌘⇧S |
Allow it for this session |
⌘⇧D |
Deny oldest request | 1–9 |
Pick a question's option |
⌘J |
Toggle the shell | ⌘⌥I |
Toggle side panel |
⌘⇧E |
Toggle sidebar | ⌘O |
Open project |
⌘, |
Settings | ⌘/ |
All shortcuts |
I loved Claude Code's agent. Making it work well for a team was the frustrating part.
- Everyone had a different setup. Getting the same skills, plugins, hooks, and tools onto every teammate's machine meant chasing missing pieces instead of building the product.
- I couldn't see the work clearly. What were my agents doing? Which files did this session modify? I wanted that answer in the workspace, not buried in terminal output.
- I wanted shared workflows, not a subscription migration. I wanted teammates to keep their individual Claude subscriptions, including Max, while working from the same playbook.
That's the reason for Keel: an opinionated environment around Claude for people who build products. Make setup visible. Keep decisions close to the conversation. Make the agent's work inspectable.
— Mohamed Alkiswani, Creator of Keel
- Download Keel for macOS or Windows, or build from source below. It updates itself after that.
- Connect Claude. Already signed in? Keel detects your setup instantly. Otherwise, Install Claude Code and Log in from Settings (
⌘,), via Anthropic's official installer and browser flow. - Open any repository. Readiness offers Add the team, then start a lane, inspect past sessions, or follow an active terminal agent.
Requires macOS 13+ or Windows, and an account with Claude Code access.
No Node.js or Homebrew required to install Claude Code. Keel uses Anthropic's official native installer and CLI browser-login flow. No separate Keel account or proxy.
- Local by default. The desktop app starts one daemon per open project and connects to its Rust daemon over
127.0.0.1. Optional paired-device access can expose the daemon over LAN or Tailscale; keep loopback mode unless you need it. - Your credentials stay yours. Keel uses your existing Claude authentication. Prompts and code go directly to Anthropic per your account terms—never to third-party intermediate proxies.
- Deterministic locks: File system and checkout locks prevent multiple agents from clobbering your Git state.
- No reporting yet. The desktop app sends no crash reports or usage events. See Privacy.
- Trust stays on your machine. Project trust and approved commands are saved outside the repository. Cloned permission files are ignored; build and installer commands are suggestions until you approve them.
- Learn more in the Guardrails & Limits Guide.
Keel is a Tauri 2 desktop app (React page, desktop/) over a Rust daemon (crates/keel), one daemon per open project. You need Rust, Node.js and pnpm.
# Clone repository
git clone https://github.com/OyadotAI/keel.git && cd keel
# Run the complete test gate (cargo test + desktop type-check, tests, bundle budget)
make check
# Run the app against a daemon built from this tree
make devThe Rust daemon can also run on its own:
cargo run -- serve .| Subsystem | Location | Role |
|---|---|---|
| App | desktop/ |
Tauri shell, React UI (lanes, chat, diffs, approvals, preview), xterm.js terminal |
| Daemon | crates/keel |
HTTP daemon, agent supervisor, Git worktree engine, monitors |
| Scanner | crates/keel-scanner |
Repository readiness checks (keel scan) |
| Workspace | crates/keel-workspace |
Reads Claude Code sessions, skills, plugins, and hooks |
| Harness | crates/keel-harness |
Claude process supervision and untrusted config quarantine |
| Providers | crates/keel-providers |
Cloudflare and GitHub integrations |
| Generator | crates/keel-generator |
Production stack templates and golden-path scaffolds |
| MCP | crates/keel-mcp |
Tool surface and Model Context Protocol catalog |
- Interactive Designer View — Live preview window showing agent UI updates in real time, with visual drag-and-drop manipulation and direct UI editing that translates changes back into structured agent instructions.
- Codex Support — Lanes can run OpenAI Codex alongside Claude Code.
- Windows Support — Signed Windows installer with automatic updates.
- Linux Support — Linux desktop and environment support for engineers running Linux workstations.
- OpenCode Support — Full compatibility and runtime integration with OpenCode.
Keel is free and open source, and will always be free to use. Contributions of all kinds are welcome!
- Check out the Contribution Guide for setup rules and testing.
- See open issues on the Issue Tracker.
- Review our Code of Conduct, Support Guide, and Security Policy.
Keel is created and maintained by Mohamed Alkiswani (mk@getoya.ai) and sponsored by OyaBrowser.com.
Source available, free for solo developers: 200 agent steps a day, with an anonymous daily usage report. Teams, companies and commercial use need a license — email sales@getoya.ai. What Keel generates in your project is yours. See LICENSE.md.