Cat Factory
A visual board, LLM coding agents, and a live view of every run in flight and every decision waiting on you. Tickets and plans go in, reviewed pull requests come out. Drive it from the board or entirely headlessly, over a versioned public API with SDKs for four languages. Free, MIT licensed, and running entirely on your own infrastructure and the coding subscriptions you already pay for.
From ticket to reviewed pull request
Import an issue from Jira, Linear, or GitHub Issues, or write the task on the board. An ordered agent chain (Architect → Coder → Reviewer → Tester → Acceptance) plans it, writes the code against a real repository checkout, reviews and tests it, opens the pull request, and comments the outcome back on the ticket.
Watch it all happen on one canvas
Zoom out for the whole system; zoom into a running task and its card opens into the live pipeline, its steps, and what it has spent. Runs in flight, failures, and decisions waiting on you appear where the work sits, and you answer a gate or retry a step right there instead of tailing logs.
100% free and open source
MIT licensed, no paid tier, no open-core holdback, nothing behind a license key. Everything on this page ships in the version you self-host, and your code, data, and model credentials never leave your own infrastructure.
You decide what agents may land
Per-task risk policies set what merges without a human, through score ceilings, rules per change class (a migration is not a test-only diff), narrowing by workspace role, retry budgets, and human decision gates you can place anywhere in a pipeline.
Scales from one engineer to a whole org
One person on a laptop and an engineering organization running every team's agent flows share the same build. Start with a model provider and nothing else; grow into directory SSO with group gating, an org-wide monthly LLM cap that meters spend and auto-pauses at the ceiling, and an audit log kept to outlive every other record. At either size, every step, decision, failure, and dollar streams live to the board, with traces exportable to OpenTelemetry or Langfuse.
A public API you can build on
A key-authenticated HTTP surface under /api/v1 covers the whole board, so a deployment can provision and run itself with nobody opening the app: link or bootstrap repositories, connect a cluster, file tasks from Jira, Linear, or GitHub tickets, start, stop, and retry runs, answer parked human decisions, read the workspace's spend, and drill into a finished run's model calls. It ships as an OpenAPI 3.1 document with official TypeScript, Python, Go, and Java/Kotlin clients generated from it, an MCP server over the same operations, and a stability contract: changes are additive, and a breaking one is served beside the old shape instead of replacing it.
Headless from ticket to merged PR
Runs started over the API execute exactly as board runs and show up on the board, with keyset-paged lists, per-run Server-Sent Events, and an outbound webhook that pushes anything needing an answer to your own endpoint. Set a run's risk policy to unattended and it takes the documented answer to each judgement call and records that it did, so a scheduled or CI-started run reaches a pull request instead of parking forever, while the gates you placed on purpose still stop it for a person.
Run it and extend it your way
One machine, Cloudflare Workers, or self-hosted Node, on the coding subscriptions you already pay for instead of metered API spend. Add your own agents, gates, task types, and integrations through a manifest model and the published @cat-factory/* packages.
What it does
You lay out work on a visual board, writing blocks yourself or importing issues from Jira, Linear, or GitHub Issues, which stay the source of truth and get progress written back to them. LLM agents pick up each block, implement it against a real repository checkout, and open pull requests for your team to review and merge. The same board is where you watch every run as it happens and step in when an agent needs you. It is self-hosted and MIT licensed, so the whole platform is yours to run.
What the board tracks is work in flight: the state of every pipeline, the stage each one reached, what it has spent, and which decisions are waiting on a person. Backlog refinement, estimation, and sprint planning stay in the tracker you already run.
Where to next?
Each card matches a section of the docs sidebar, so the path you pick here is the same one you will follow in the navigation.
Integrations
Cat Factory connects to the tools you already use. Everything below ships in every deployment.
| Category | Connects to |
|---|---|
| Repositories & pull requests |
|
| Issue trackers |
|
| Document & context sources |
|
| Model providers |
|
| Sign-in |
|
| Notifications |
|
See Connect Issue & Document Sources and Connect a Model Provider for setup.
Advanced capabilities
Build & review
- Multi-stage agent pipelines — ordered chains with per-agent models and human decision gates.
- Requirements & spec — a reviewer agent flags gaps and risks per task; the Spec Writer keeps a unified, in-repo spec with Gherkin acceptance scenarios.
- Visual confirmation (experimental) — a UI Tester screenshots each screen, then a gate parks for you to compare them against reference designs.
- Custom agents & gates — extend the pipeline through a manifest model and the published
@cat-factory/*packages.
Test & iterate
- Sandbox — test prompts and models side by side against graded fixtures, scored by a judge, before you commit to a preset.
- Ephemeral environments — spin up a live preview per run for integration and end-to-end tests, then tear it down automatically.
- Recurring pipelines — schedule dependency bumps and tech-debt passes to ship as reviewed PRs on a cadence, with no one kicking them off.
Operate
- Durable runs — every run is checkpointed, survives interruptions, and resumes where it left off.
- Live observability — watch each step, decision, failure, and spend update stream over WebSockets.
- Budgets & metering — an org-wide monthly LLM cap with per-run metering, prompt caching, auto-pause, and rollover resumption.
- Runner pools — provision agent containers across your own runners.
Collaborate
- Shared services — one account-owned service mounts onto many teams' boards as a single synced copy.
- Members, roles & invitations — invite teammates into a shared organization with role-based access.
- Localized, mobile-friendly UI — English, Spanish, French, Polish, and Ukrainian, with a responsive board shell (touch pan, pinch zoom, phone minimap).
Deploy anywhere
| Runtime | Best for |
|---|---|
| Local mode | One machine, no cloud account: fastest way to try it end to end. Agents clone, commit, and push to real repos; CI gates on real GitHub Actions. |
| Cloudflare | Heavy production workloads on Workers (D1, Durable Objects, Workflows). |
| Node.js | Self-hosted production on Node with PostgreSQL and pg-boss. |
Run agents on a coding subscription you already hold (Claude Pro/Max, GLM Coding Plan, or ChatGPT/Codex) instead of metered API spend. These plans are kept per-user, so each vendor's individual-use terms stay respected, and they unlock subscription-only models with no API-key equivalent. For shared, org-wide access, set a direct provider key, an aggregator like OpenRouter, Bifrost or LiteLLM, or run a local model with no key and no spend.
A note on scope
This site documents how to deploy and use Cat Factory. For source code, issues, and contribution guidelines, head to the kibertoad/cat-factory repository.