Run a fleet,
command the operation.
Control Center is the native deck for your whole developer operation. Dispatch coding agents onto isolated worktrees, review what they ship and keep tickets, meetings and pipelines in one quiet, well-instrumented place.
Free and open source · macOS, Windows, Linux and web · No account needed for the demo
Full app window, light theme, real data: sidebar with the pillar rail, the agents grid with live status pills (running, blocked, done), one agent transcript streaming on the right, today’s meetings in the agenda and the token-cost ticker in the header.
The agents grid mid-flight: six agent cards with status pills (two running, one blocked on an approval, the rest done), a live transcript streaming in the side panel and per-run token cost in the card footer.
A Browser (VM) tab beside the chat: the live machine view with the agent mid-click, the Take control button in the header, the forwarded-ports popover showing 3000 → 3000 (node) and the enclosed terminal’s VM badge.
The review surface on a real diff: syntax-highlighted hunks, two inline comment threads, an AI reviewer’s rolled-up verdict with P0–P3 findings and the ship / hold / block actions in the header.
A recorded meeting’s notes next to the calendar week: diarized transcript with speaker names, the AI summary, extracted action items with owners and the on-device privacy marker.
One deck for the whole operation.
Agents are one pillar among co-equal ones. The same vocabulary (status, ownership, next action) carries across all of them.
See what every agent is doing.
Each agent runs on its own branch, in its own copy-on-write worktree. Thinking, running, blocked, failed, idle: every state reads differently at a glance, with live token cost and last-output age per run.
- Presence is earned by representing the agent model truthfully, never by decoration.
- Steer a run mid-flight, take over, or hand it back.
- Ownership and attribution stay legible as teammates join.
The agents grid mid-flight: six agent cards with status pills (two running, one blocked on an approval, the rest done), a live transcript streaming in the side panel and per-run token cost in the card footer.
Hand an agent a whole machine, safely.
When an agent needs to actually try something — load the page, click through the app, run the risky command — it opens a rig: a disposable VM with its own kernel, a throwaway disk and a network that reaches only the hosts you allowed. You watch it work live and take the controls at any time.
- A browser, a Linux desktop, a phone, or an enclosed terminal — booted in seconds, scoped to the conversation you share.
- Start a dev server inside and it is on localhost, in the agent’s browser and under https://myapp.test moments later.
- git push works with no credential in the VM; every input lands in an audit log with its author.
- Nothing inside ever touches your machine, and the disk is destroyed on close.
A Browser (VM) tab beside the chat: the live machine view with the agent mid-click, the Take control button in the header, the forwarded-ports popover showing 3000 → 3000 (node) and the enclosed terminal’s VM badge.
Review and merge what the fleet ships.
Priority pull requests surface first, from every forge at once. Read the diff, drop inline comments, dispatch reviewer agents and land a ship / hold / block verdict without leaving the deck.
- One inbox across GitHub, GitLab and Bitbucket.
- Inline threads synced back to the forge, with suggested edits.
- AI reviewers with P0–P3 findings and a rolled-up verdict.
- An ephemeral focus mode for distraction-free review.
The review surface on a real diff: syntax-highlighted hunks, two inline comment threads, an AI reviewer’s rolled-up verdict with P0–P3 findings and the ship / hold / block actions in the header.
Your day and your meetings, on the same deck.
Record a call and the deck transcribes it on-device, separates the speakers and writes the summary, decisions and action items. Connect Google Calendar to see your day and turn any event into a recorded, summarized meeting.
- On-device transcription and diarization; audio never leaves your machine.
- Google Calendar in month, week and agenda views, with RSVP.
- A heads-up before each meeting and record-and-link straight from an event.
A recorded meeting’s notes next to the calendar week: diarized transcript with speaker names, the AI summary, extracted action items with owners and the on-device privacy marker.
Orchestrate the fleet as a DAG.
Compose steps into a graph: prompt an agent, run a script, fan out reviewers, join the results. Runs start by hand, on a schedule, or off a domain event and every node carries its own retry and continue-on-fail policy.
- Three triggers: manual, scheduled, or domain-event.
- Router and join nodes for conditional, parallel work.
- Resumable runs that survive a restart mid-flight.
Plan Studio with a pipeline run in flight: the DAG with trigger, fan-out reviewers and join nodes, one node mid-retry showing its attempt counter and the per-run cost rollup at the bottom.
The small pillars, held to the same bar.
Tickets
One vendor-agnostic ticket carries work from request to merge: two-way Linear sync, a coupled pipeline run and an execution lock so two agents never claim the same work.
Read the guideSpaces & multiplayer
Humans and agents share one roster as co-equal principals. DM an agent, spin up a space per worktree, follow a teammate’s cursor and steer a run mid-flight.
Read the guideSlack & chat bridges
Mention an agent where you already talk and it answers in the Slack thread. Bridges relay messages into real spaces with full attribution and narrate workspace provisioning as it happens.
Read the guideInbox & newsfeed
A unified inbox across every pillar, a ⌘K omnibox to act from anywhere and RSS feeds folded into the same triage flow. Nothing waits in a tab you forgot.
Read the guideFocus & soundscape
A timed session floats a draggable countdown pill and silences every notification that can wait. Under it, a soundscape synthesized by your server follows the weather, the hour and a tune you dial in.
Read the guideThe systems that keep a fleet legible.
Agents, review and pipelines all sit on the same foundation. Each system exists so a run starts with more context and you keep more control, than the run before it.
Memory that compounds across runs.
Every workspace keeps facts, policies and domains in one hybrid store: full-text and vector search over a knowledge graph. An agent opens its run with the context the last run earned, gated to exactly what its role may read.
Your codebase, read as a graph.
A tree-sitter symbol-and-edge index per repo lets an agent jump from a symbol to its callers, callees and blast radius before it edits a line: the same impact view you get when you review the result.
One hundred tools, one open protocol.
A JSON-RPC server exposes agents, review, the code graph, memory and ticketing to any MCP client. Mode gating and approval prompts sit in front of every call, so a tool never outruns the policy you set.
One loop, eight runners.
The built-in runtime is a pure-Dart agent loop (streaming, tool calls, compaction, steering, subagents) that runs inside cc_server, so it needs no external CLI. Seven more adapters wrap the CLIs you already have: Claude Code, Codex, Pi, OpenCode, Gemini CLI, Goose and Cursor. Model providers connect by browser sign-in or API key and any OpenAI- or Anthropic-compatible endpoint joins as a custom provider.
Secure by construction.
Each space runs inside an OS-native sandbox (Seatbelt on macOS, bubblewrap on Linux) over copy-on-write worktrees. Credentials are minted per launch, capability-gated, brokered in memory and revoked on teardown.
Every screen you own, one operation.
The same app runs native on macOS, Windows and Linux, in the browser at app.usectrl.dev and as a phone companion. Every client is a thin renderer over one cc_server that owns your data.
Windows
Control-Center-<v>-x64-setup.exeControl-Center-<v>-windows-x64.zipx64 · Windows 10+ · portable zip also available
Download .exeLinux
Control-Center-<v>-x86_64.AppImageControl-Center-<v>-linux-x64.tar.gzx86_64 · tar.gz also available
Download AppImageWeb app
Nothing to install. Connects to a cc_server you run.
Phone companion
Remote pairs with your server over a sealed relay.
Self-hosting? Every release also ships the headless cc_server for macOS, Linux and Windows, plus Docker images on GHCR. See Run a headless server.
Free and open source · auto-updates on desktop
New to Control Center? Start with the quick-start guide, or browse the full documentation.
Learn the deck, guide by guide.
Short, task-shaped guides. Each one ends with the thing working, not with homework.
Asked, answered.
The short versions; the manual has the long ones.
What is Control Center?
Control Center is a free and open-source developer operations deck: one native app where you dispatch AI coding agents across isolated Git worktrees, review and merge what they ship, and run the surrounding operation — tickets, pipelines, meetings, calendar, memory — side by side with them. It runs on macOS, Windows and Linux, in the browser and on your phone, all rendered from one server you own.
How is Control Center different from running several Claude Code terminals?
Terminals give you N agents and zero cross-agent visibility. Control Center gives each agent its own copy-on-write worktree, sandbox and budget, then adds everything the terminals cannot: a PR review cockpit with AI reviewers and merge actions, pipelines that trigger work on schedules or domain events, durable agent-to-agent messaging, long-term memory and a code graph every run starts from. You steer any run mid-flight, take it over, or hand it back.
Which AI coding agents does Control Center support?
Eight runners: a built-in pure-Dart agent runtime that needs no external CLI, plus adapters for Claude Code, Codex, Pi, OpenCode, Gemini CLI, Goose and Cursor. Any OpenAI- or Anthropic-compatible endpoint also joins as a custom provider. You can mix runners in the same fleet and the same pipeline.
Does my code or data leave my machine?
No, unless you decide to run it that way. Control Center is local-first: state lives in SQLite files you own, meeting transcription and speaker diarization run on-device, and semantic-search embeddings are computed by an on-device model. your code host and Linear are called only from your own server, over credentials stored in your OS keychain.
Can an agent test in a real browser or run risky commands safely?
Yes — that is what rigs are for. A rig is a disposable VM the agent drives in real time: a headless browser, a Linux desktop, an Android device, or the machine behind an enclosed terminal. It has its own kernel, a throwaway disk and a network that reaches only the hosts you allow; you watch it live and can take the controls at any moment. Dev servers started inside are forwarded to localhost, to the agent’s browser and to dev domains like https://myapp.test — and nothing inside a rig ever touches your machine.
Is Control Center free and open source?
Yes — MIT-licensed, source on GitHub, with signed builds for every platform. The desktop apps, the headless server and the phone companion are all free; you bring your own agent subscriptions or API keys, and the built-in runtime can use any provider you can reach.
Which platforms does it run on?
Native desktop apps ship together for macOS (Apple Silicon, signed and notarized), Windows and Linux, with auto-updates. The same server also serves a web app at app.usectrl.dev and a phone companion at remote.usectrl.dev, so the operation follows you across screens without a rewrite.
Can my team use Control Center together?
Yes. Humans and agents are co-equal members with workspace roles — owner, admin, member, viewer or guest — plus per-repo grants, invites and live revocation. Presence shows who is working on what (including watching an agent work), and every space carries an autonomy dial: propose-only, act-with-approval or act-freely. With one human, the multiplayer chrome simply idles.
Which code hosts does Control Center work with?
GitHub, GitLab and Bitbucket Cloud — and one workspace can hold repos from all three at once. Each repo is talked to through its own forge with its own credential, and the inbox merges pull requests from every one of them into a single stream. The full loop works everywhere: list and open PRs, read diffs, comment inline and at top level, review, merge, close and create. Forges genuinely differ beyond that (stacked PRs and synced viewed-state are GitHub-only, for instance), so the app hides what a host cannot do rather than showing a control that silently fails.
How does Control Center work with Linear?
Linear syncs tickets bidirectionally with projects, statuses, labels and assignees; Jira and ClickUp providers are scaffolded. Tickets themselves are vendor-neutral, so the same board works whichever tracker you sync.
Take command of the fleet today.
Free and open source. Desktop on macOS, Windows and Linux; the same app in your browser and on your phone.