Three agents, one localhost:3000, one shared database: that is where parallel agents break.
Blame gives each agent its own worktree, ports, services, and running app, so you try every change before it merges.
Free and open source · No account needed · Works with your Claude or ChatGPT plan
Install · Website · Docs · Discord · Discussions · Roadmap · Contributing · Code signing policy
Download the latest release for your platform:
| Platform | Download | Requirements |
|---|---|---|
| macOS (Apple silicon) | blame-mac-arm64.dmg |
macOS 13 or later |
| macOS (Intel) | blame-mac-x64.dmg |
macOS 13 or later |
| Windows (x64) | blame-win-x64.exe |
Windows 10 or 11 with WSL 2 |
| Linux (x86_64) | AppImage · .deb · .rpm |
Docker Engine with the Compose plugin |
On macOS, you can also install it with Homebrew:
brew install --cask rchrp/tap/blameComing soon: winget on Windows, once its package is merged, and the AUR package (blame-bin) on Arch, once AUR account registration reopens. I use Arch, btw: it is coming.
Then open Blame and choose Continue without an account. Quick start takes you from there to your first merge.
Blame keeps itself up to date. Older versions and betas are on the releases page and blame.so/download; the Code signing policy explains how releases are built and signed.
Platform notes
macOS. The app is signed and notarized. On first launch, Blame sets up a small Linux VM (based on Lima) where agents, worktrees, and previews run.
Windows. The installer is not code-signed yet (signing through SignPath Foundation is planned), so SmartScreen may warn you: choose More info → Run anyway. The installer lets you turn off the update check at launch; Settings → Desktop → Privacy has the same switch. Blame runs agents in its own WSL distribution. If WSL is not installed, run wsl --install in an administrator terminal and restart first.
Linux. Worktrees stay native, and previews and project services run in Docker on your machine.
# AppImage
chmod +x blame-linux-x86_64.AppImage && ./blame-linux-x86_64.AppImage
# Debian, Ubuntu
sudo apt install ./blame-linux-amd64.deb
# Fedora, RHEL
sudo dnf install ./blame-linux-x86_64.rpmVerify a download. Each release ships a SHA256SUMS file:
shasum -a 256 -c SHA256SUMS --ignore-missingBeta channel. Turn on Settings → Desktop → Beta channel to get prereleases as soon as they ship.
Git worktrees stop parallel agents from editing the same files. They do not stop them from fighting over everything else: the dev server port, the database, the cache, the .env. Run three agents and you get three branches, but only one app you can open.
Blame isolates the running app, not just the code. Each story gets:
- its own branch and worktree;
- its own containers for the app and its services (database, cache, workers), on their own ports;
- its own live preview, next to the agent's files, diffs, logs, and terminal.
You try each change in its running app, then request changes, reject it, or approve and merge. Nothing merges until you say so.
- Agents that show their work. Agents run through the Light Semantic Harness: every read, edit, and check is recorded, and checks run again before hand-off. On six hand-audited TypeScript tasks, it matched Cline's results with 54% fewer tokens.
- Your models, your machine. Sign in with your Claude or ChatGPT plan, or use any of 50 AI providers with your own key. Agents, worktrees, and previews run on your computer.
- Free and open source. The whole app is AGPL-3.0, and works without an account. Blame Cloud only adds hosted services, such as Cloud Previews.
- Open Blame and choose Continue without an account, or sign in. Blame remembers the choice.
- Connect an AI provider: sign in with your Claude or ChatGPT plan, or paste an API key.
- Open a Git repository, or create a new project from a web stack. Blame prepares how the project runs in a preview.
- Write two or three user stories in the backlog and start an agent on each. They run at the same time.
- Open each story's Preview tab to try its own running copy of the app. Request changes, reject the work, or approve and merge.
For a quick fix or a question about the code, skip the backlog and use Quick Chat.
Everything above stays on your computer. Sign in later to sync across computers or use hosted services: your workspace moves into the account.
When you open a repository, a setup agent reads it and writes down how the project runs: the app, its services (PostgreSQL, Redis, workers, and so on), and how to start them. Each story then gets its own copy of that setup.
| Project | Preview |
|---|---|
| Web apps and APIs that run on Linux | The page in a built-in browser |
| Linux GUI, Electron, and Tauri apps | A screen of the running app |
| Apps that cannot run in a container | Direct mode: the app runs in your project folder, without isolation |
In development: terminal previews for CLI tools, phone and tablet frames, the iOS Simulator, and the Android emulator.
New projects start from Next.js, React + Vite, Nuxt, Vue + Vite, or SvelteKit, with PostgreSQL, MySQL, SQLite, or MongoDB.
A stack that does not preview well? Open an issue with the project's stack: that list is the one we fix first.
These are good tools, and all of them run agents in parallel git worktrees. The difference is what happens to the running app: who gets which database, which ports, which services.
| Blame | Emdash | Conductor | Claude Squad | Vibe Kanban* | |
|---|---|---|---|---|---|
| Open source | AGPL-3.0 | Apache-2.0 | No | AGPL-3.0 | Apache-2.0 |
| Platforms | macOS, Windows, Linux | macOS, Windows, Linux | macOS | macOS, Linux | macOS, Windows, Linux |
| Interface | Desktop app | Desktop app | Desktop app | Terminal (tmux) | Web UI |
| One worktree per agent | ✓ | ✓ | ✓ | ✓ | ✓ |
| Live preview of each task's app | ✓ | ✓ | ✓ | — | ✓ |
| Ports per task | Automatic | A range per task | A range per task | — | Set by hand |
| Database and services per task, locally | Automatic, in containers | Your own Docker Compose setup | Shared (docs suggest one run at a time) | — | Your own scripts |
| Agents | Its own agent, on your Claude or ChatGPT plan or 50 providers | 35 CLI agents | Claude Code, Codex, OpenCode, Cursor | Claude Code, Codex, Gemini, Aider | 10+ CLI agents |
| Account required | No | No | GitHub login | No | No |
Checked on November 2, 2026, against each project's own docs. *Bloop wound down Vibe Kanban in April 2026; it is community-maintained since, without its kanban board. Something wrong or out of date? Open an issue and it gets fixed.
Most coding agents grep, rewrite whole files, and tell you it should work now. Blame gives every agent five guarded tools instead:
| Tool | What the agent does | What the harness guarantees |
|---|---|---|
search_code |
Finds code by its structure | Declarations come from the syntax tree and the TypeScript project, not from text matches. |
read_code |
Reads before it writes | Every read is recorded with the file version it saw. Unread code cannot be edited. |
edit_code |
Edits declarations and files | An edit must match the exact text the agent read. Stale or ambiguous targets are refused, and batches are atomic. |
run_task |
Runs commands and tests | Results are bound to the run and the source revision. A failing test stays failed, even behind a script that exits 0. |
finish_task |
Hands the work back | Required checks run again on the final source. Missing or stale checks are reported as unverified, with the reason. |
Measured in the open. On fresh cross-module TypeScript tasks audited by hand, the harness matched Cline's 6/6 with 54% fewer tokens and a 39% lower estimated cost. That is panel F61 of the harness study (LaTeX source), which details the conditions, the other panels, and the limits of each result. The harness lives in packages/agent-runtime/src/harness.
| Backlog to merge | Live preview and review |
|---|---|
| Code Practices | Project creation |
- Backlog-driven development. Each user story becomes a lane that keeps its brief, context, agent activity, review notes, and final decision through queue, development, review, and merge.
- Smart worktrees. Blame analyzes the project and prepares a dedicated branch, worktree, environment, port, and runtime for each story before the agent starts.
- Live previews. Run each worktree's app beside its story, with files, diffs, logs, and terminal output. Cloud Previews can also run it in a managed sandbox.
- Controlled merge. Request another pass, reject the work, or approve and merge. The agent moves fast; the decision stays yours.
- Parallel agents, any model. Run several agents at once across 50 AI providers, plus any OpenAI-compatible API.
- Code Practices. Hold every agent to your conventions, or to a stricter engineering standard, project by project.
- Specialist agents. Codebase, story, frontend design, verification, and risk specialists sharpen the work while one lead agent stays responsible for it.
- MCP servers. Connect your MCP servers to every agent.
- Project creation. Start from an empty folder: pick a web stack and Blame generates a project ready for agent work.
- Optional account sync. Sign in to have stories, conversations, Code Practices, provider connections, and MCP servers follow you to another computer.
Blame is free and open source. Blame Cloud pays for hosted services that cost money to run.
| Free, no account needed | Blame Cloud (with an account) |
|---|---|
| Projects, backlog, and conversations | Cloud voice transcription |
| Local worktrees and local previews | Managed Cloud Previews |
| Your own AI provider credentials | New hosted file uploads, including deployment source archives |
A free account adds sync between computers, web research for agents, and deployment to Vercel.
Blame Cloud is $20/month or $200/year. Your AI provider bills its own usage. Files stay accessible after a subscription ends. See blame.so/cloud.
- No telemetry. Blame sends no usage metrics, traces, logs, or crash reports, with or without an account. Agents call only the AI provider you pick.
- Update check. At launch, the app asks
download.blame.sowhether a newer version exists. Turn it off in Settings → Desktop → Privacy; the Windows installer offers the same switch. - Reporting a problem. When something fails, Report on GitHub opens a pre-filled issue in your browser. Nothing is sent unless you submit it.
The privacy policy lists every connection the app makes, such as runtime downloads and, with an account, sync with api.blame.so.
Where does my code run?
On your computer. Local execution uses a Lima VM on macOS, a WSL distribution on Windows, and native worktrees with Docker on Linux. Code is sent to the AI provider you choose when an agent needs it. Cloud Previews, part of Blame Cloud, sync a workspace snapshot to a managed sandbox.
Which AI providers can I use?
Any of the 50 supported providers, with your own API key or subscription, plus any OpenAI-compatible endpoint. You can use a different model for each agent.
Do I need an account?
No. The first screen offers to sign in or to continue without an account, in the same panel. Without an account, Blame keeps your projects, stories, conversations, Code Practices, and provider connections on your computer, in a local database. Provider keys are encrypted with a key held by your system keychain. Agents, worktrees, previews, review, and merge work without Blame's servers: agents only call your AI provider.
A free account adds what needs a server: sync between computers, web research for agents, deployment to Vercel, and Blame Cloud. When you sign in, your local workspace is copied into the account and stays on your computer too. Signing in again later only adds what is missing.
Can I self-host the backend?
For one person, it already is: without an account, the desktop app runs the same API on your computer, on SQLite. Hosting it for a team is not turnkey yet. The development setup in CONTRIBUTING.md runs the whole stack locally, and the open-source readiness summary tracks what self-hosting still needs.
Why Electron, and not Tauri or something else?
Because live previews are the product, and Electron is the only option that makes them work the same on macOS, Windows, and Linux.
- Agents drive the preview with standard tools. Each story's preview is a real browser, and the agent inspects it through the Chrome DevTools Protocol (CDP): console, network, DOM, clicks, screenshots. Electron embeds Chromium, so CDP is built in and every agent-side browser tool works unchanged.
- Tauri uses the system webview, and most of them do not speak CDP. macOS uses WKWebView and Linux uses WebKitGTK, both WebKit, with a different inspection protocol. Only Windows (WebView2) is Chromium. Since macOS is a main target, Tauri would have meant either a second browser running beside the app, or bundling Chromium anyway (CEF), which removes Tauri's size advantage.
- The preview must render like your users' browser. A WebKit preview on macOS, Chromium on Windows, and something else on Linux would show different bugs on each machine. One bundled Chromium means what you review is what you ship.
- One language, one codebase. The desktop app shares TypeScript with the interface, the API, and the agent runtime. A Rust layer would add a second stack to maintain for little gain.
What about performance? The interface is not where the time and memory go. The costs are the agents, the language models, the containers, and the Lima VM or WSL distribution that runs your project. Electron adds some memory at idle, which is small next to a Postgres container and a dev server per story, and it does not slow down the agents. Spending that memory buys previews that work the same everywhere and that agents can test.
If your project is itself a Tauri app, Blame can preview it. The choice only concerns what Blame is built with.
Blame is a TypeScript monorepo (pnpm and Turborepo): an Electron desktop app, a React interface, an AdonisJS API, and the agent runtime.
git clone https://github.com/rchrp/Blame.git
cd Blame
corepack enable
pnpm install --frozen-lockfileYou need Node.js 24, Git, and MySQL 8.4 for the API. CONTRIBUTING.md walks through configuring the API, running the desktop app, the checks to run, and how the repository is organized. RELEASING.md covers packaging and releases.
- User documentation: install, guides, concepts, and troubleshooting. Its pages live in
packages/vitrine/content/docs. - Architecture: package boundaries, workspace execution, and the harness architecture.
- Semantic harness study (LaTeX source): measured results, implementation guarantees, limitations, and research directions. Rebuild the PDF with
pnpm build:study-pdfafter editing the source. - Refactoring summary: module responsibilities and validation.
- Open-source readiness: licensing, self-hosting, and release preparation.
- Releasing: how the desktop app and its runtimes are built and published.
- Chat, help, and show what you built: Discord
- Questions and ideas: GitHub Discussions
- Bugs and feature requests: GitHub Issues
- Security reports: see SECURITY.md. Please do not open a public issue.
- Roadmap: what's planned now, next, and later, on the Blame ADE Roadmap.
- Contributing: start with CONTRIBUTING.md and the code of conduct, then pick one of the good first issues.
If Blame is useful to you, a star helps other developers find it.
Blame's agent runtime is built on the Cline SDK. Its macOS runtime uses Lima, and code navigation uses ast-grep and Tree-sitter.
Blame is licensed under the GNU Affero General Public License v3.0 (AGPL-3.0-only).
You may use Blame commercially. If you distribute it, you must provide the corresponding source under the same license. If you modify Blame and let users interact with it over a network, you must offer them the source of your modified version, as section 13 requires. Third-party components keep their own licenses and notices.