cat-factory
Plan software work on a visual board, and let LLM agents deliver it as reviewed, CI-green pull requests while your team keeps the decisions.
Website & docs · Introduction · · ·
Agenten stärken
Der eigene Befehl des Herausgebers. Kein PlugMCP-Endpunkt.
Host a copy with our keys and logs.
npx -y @cat-factory/[email protected]Claude Code hat keinen Installationslink für einen lokalen Befehl. Kopieren Sie den Befehl unten und führen Sie ihn in einem Terminal aus.
claude mcp add cat-factory-mcp-server -- npx -y @cat-factory/mcp-server@0.64.0In einem Terminal ausführen.
{ "mcpServers": { "cat-factory-mcp-server": { "command": "npx", "args": [ "-y", "@cat-factory/[email protected]" ] } }}claude_desktop_config.json
Remote-URL oder ein Befehl auf Ihrem Rechner? Worin sich die beiden Installationen unterscheiden
Auf PlugMCP ausführen
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
StartenVom Herausgeber
Plan software work on a visual board, and let LLM agents deliver it as reviewed, CI-green pull requests while your team keeps the decisions.
Website & docs · Introduction · · ·
Model Context Protocol server for the cat-factory public API (/api/v1): a thin facade that exposes the published operations as MCP tools, generated from the same OpenAPI spec the SDKs are, over the hand-written @cat-factory/sdk transport.
cat-factory is a self-hosted platform for running software delivery with agents. You lay out your services and the tasks inside them on a board, or pull tasks in from Jira, Linear, GitHub or GitLab. For each task, an agent pipeline does the work: it settles the requirements with you, writes the code on a real checkout of your repository, reviews and tests it, and opens a pull request that waits for green CI and your merge policy. You watch every step live and step in wherever a person should decide.
It runs on your own infrastructure (your laptop, a Node.js server, Kubernetes or Cloudflare) with the model providers you choose.
Along the way you choose which model runs each step, which steps need a human sign-off, and how much the organisation may spend per month. When a run needs you, the queue lists it under Needs you, or under Ready to merge once its pull request waits to land.
You need Node 24 or newer and a container runtime (Docker, Podman, OrbStack, Colima or
Apple container). One command scaffolds a local deployment in a new directory:
npx @cat-factory/cli init
It asks a few questions (project name, whether agents run in Docker or through your own installed
claude/codex CLI, GitHub or GitLab), generates the secrets the server needs, and helps you mint
a source-control token. Then start the two halves, each in its own terminal:
cd <project>/local && npm install && npm run db:up && npm start # backend on :8787
cd <project>/frontend && npm install && npm run dev # app on :3000
The first backend start takes a minute while it pulls the image agents run in. Open http://localhost:3000, add a model provider (Cloudflare Workers AI is the quickest; any vendor API key works), connect a repository, and start your first task. The first task tutorial walks through that run step by step.
More detail: Run locally on the website, and the
@cat-factory/cli reference for every flag and subcommand.
The product documentation lives on catfactory.ai. This repository documents how cat-factory is built.
A short tour. Every capability is described in full in
docs/capabilities.md.
/api/v1 with official TypeScript, Python, Go and Java
clients, and an MCP server.flowchart TB
SPA["<b>Nuxt SPA</b> · frontend/app<br/>Vue Flow board"]
subgraph neutral["Runtime-neutral backend (the same code on every target)"]
HTTP["<b>HTTP layer</b> · @cat-factory/server<br/>Hono controllers, auth, RBAC"]
DOMAIN["<b>Domain</b> · orchestration, integrations, agents<br/>the delivery engine and its registries"]
PORTS["<b>Ports</b> · @cat-factory/kernel<br/>repositories, durable execution, events, VCS, models"]
HTTP --> DOMAIN --> PORTS
end
subgraph facades["Runtime facades (one per deployment target: adapters only)"]
CF["<b>Cloudflare Worker</b><br/>D1 · Workflows · Durable Objects · Containers"]
NODE["<b>Node service</b><br/>Postgres/Drizzle · pg-boss · realtime hub · runner pool"]
LOCAL["<b>Local</b><br/>the Node stack, containers on your machine"]
end
JOB["<b>Per-run container</b><br/>executor-harness drives a coding agent<br/>on a real checkout"]
VCS[("GitHub / GitLab<br/>branch, PR, CI, merge")]
SPA -- "REST" --> HTTP
HTTP -. "events PUSHED over WebSocket, never polled" .-> SPA
PORTS --> CF & NODE & LOCAL
CF & NODE & LOCAL -- "dispatch" --> JOB
JOB -- "clone, implement, push" --> VCS
JOB -- "progress, telemetry" --> PORTS
A run is durable: the server advances it one checkpointed step at a time, so it keeps going whether or not a browser is open and survives restarts. The long agent work happens in a container, and every state change is pushed to the board as it happens.
Everything above the facade line is the same code on every deployment target. Each facade supplies only the storage, job queue and container adapters for its platform, and a shared conformance suite runs the same assertions against all of them.
Deeper reading: Architecture on the website, the backend overview, and the flow index for each runtime flow in turn.
cat-factory ships as libraries on npm plus a runner image on GHCR and Docker Hub. A deployment is a
small project of its own that depends on those packages and carries its own configuration and
secrets. The deploy/* directories here are templates to copy: every id and hostname in them is
a placeholder, and this repository operates no deployment of its own.
Every target also needs a source-control connection (GitHub App or a GitLab token) and sign-in (configuration, enterprise SSO). Every environment variable is listed in Environment variables.
Already running a Kubernetes cluster? Agent jobs and per-pull-request preview environments can run on it, whichever target hosts the backend: Kubernetes.
One pnpm workspace. The short map:
Every package, its role and where it is published:
docs/repository-layout.md.
Everything above is about using the platform. This part is for changing it.
CONTRIBUTING.md: setting up the workspace, the common commands, and the
changeset every PR needs.AGENTS.md: the rules every change is held to (runtime symmetry, size ratchets,
compatibility, logging and more). It is also what orients a coding agent, and each package
carries its own AGENTS.md with a "where things live" map.docs/README.md: the map of this repository's docs, including the feature
guide that pairs each capability with its website page and its design doc.docs/glossary.md: the code-level naming map (block vs task vs card,
directory vs package names). The product vocabulary is the website's
Glossary.Model Context Protocol server for the cat-factory public API (/api/v1): a thin facade that exposes the published operations as MCP tools, generated from the same OpenAPI spec the SDKs are, over the ha
{ "mcpServers": { "cat-factory-mcp-server": { "command": "npx", "args": [ "-y", "@cat-factory/[email protected]" ] } }}Übersicht
Model Context Protocol server for the cat-factory public API (/api/v1): a thin facade that exposes the published operations as MCP tools, generated from the same OpenAPI spec the SDKs are, over the hand-written @cat-factory/sdk transport.
Tools
Noch keine Tool-Liste. Remote-Server erhalten eine nach dem ersten Health-Check.
FAQ
Kopieren Sie auf dieser Seite die stdio-Konfiguration für Cursor, Claude Desktop, Claude Code oder VS Code. Sie nutzt die Installation des Herausgebers, keinen PlugMCP-Proxy.
In diesem Eintrag ist keine erforderliche Umgebungsvariable aufgeführt.
@cat Factory/ läuft lokal über stdio.
Zuletzt geprüft: 2026-11-16. Model Context Protocol server for the cat-factory public API (/api/v1): a thin facade that exposes the published operations as MCP tools, generated from the same OpenAPI spec the SDKs are, over the hand-written @cat-factory/sdk transport.