# Control Center — the developer operations deck

> Dispatch and review AI coding agents, hand them disposable VMs to test in, capture and summarize meetings and keep tickets, pipelines and your calendar on one deck. Desktop on macOS, Windows and Linux, plus web and phone.

Control Center is a free and open-source (MIT) developer operations deck, self-hosted first.

- Platforms: native desktop apps for macOS (Apple Silicon, signed/notarized), Windows and Linux with auto-updates; web app; installable phone companion (remote.usectrl.dev). Every client is a thin renderer over one headless cc_server binary you run (macOS/Linux/Windows, plus Docker images on GHCR) — the server owns the database, external APIs and execution.
- Agents: a built-in pure-Dart agent runtime (streaming, tool calls, compaction, steering, subagents) plus adapters for Claude Code, Codex, Pi, OpenCode, Gemini CLI, Goose and Cursor. Any OpenAI- or Anthropic-compatible endpoint joins as a custom provider; runners can be mixed in one fleet.
- Isolation and safety: every space runs in its own copy-on-write Git worktree inside an OS-native sandbox (macOS Seatbelt, Linux bubblewrap); credentials are minted per launch, capability-gated and revoked on teardown. A unified guardrail store covers ~12 action classes with a per-space autonomy dial (propose-only / act-with-approval / act-freely); unattended approval prompts fail closed.
- The operation around the fleet: PR review cockpit with AI reviewers (P0-P3 findings, ship/hold/block verdicts) across GitHub, GitLab and Bitbucket, merged into one inbox; vendor-agnostic tickets with bidirectional Linear sync (Jira and ClickUp scaffolded); DAG pipelines with manual, cron and domain-event triggers, resumable runs and approval gates; on-device meeting transcription with diarization and summaries; Google Calendar; per-user RSS/Atom newsfeed with ad blocking.
- Knowledge: long-term memory with role-gated access policies, and a tree-sitter code graph (symbols, callers/callees, impact radius) with hybrid BM25 + vector semantic search computed by an on-device embedding model.
- Multiplayer: humans and agents are co-equal members with workspace roles (owner/admin/member/viewer/guest), per-repo grants, presence, follow mode, steer/take-over/hand-back and live revocation. Agents collaborate over durable spaces (send_to_agent, ask_agent, delegate_task with budget inheritance and autonomy ceilings).
- Tool surface: 100+ typed MCP tools over JSON-RPC, every workspace-scoped tool requiring its workspace_id; an MCP client bridges external MCP servers into the same registry.
- Source: https://github.com/SamuelAlev/control-center

## Frequently asked questions

### 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.

See also: [Read the manual](https://usectrl.dev/manual/) · [What shipped lately](https://usectrl.dev/changelog)

### 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.

See also: [How it works](https://usectrl.dev/manual/concepts/architecture/) · [Run agents in parallel](https://usectrl.dev/manual/guides/parallel-agents/)

### 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.

See also: [Agent runners and adapters](https://usectrl.dev/manual/guides/adapters/)

### 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.

See also: [Security model](https://usectrl.dev/manual/concepts/sandbox-security/)

### 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.

See also: [Give an agent a machine](https://usectrl.dev/manual/guides/use-rigs/) · [How enclosures work](https://usectrl.dev/manual/concepts/rigs/)

### 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.

See also: [Install it](https://usectrl.dev/#install)

### 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.

See also: [Download](https://usectrl.dev/#install)

### 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.

See also: [Multiplayer concepts](https://usectrl.dev/manual/concepts/multiplayer/)

### 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.

See also: [Connect a code host](https://usectrl.dev/manual/guides/connect-forges/) · [GitHub integration](https://usectrl.dev/manual/guides/github-integration/)

### 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.

See also: [Linear integration](https://usectrl.dev/manual/guides/linear-integration/)

## Learn more

- [Documentation](https://usectrl.dev/manual/) — tutorials, guides, concepts and reference
- [Developers](https://usectrl.dev/developers) — MCP server, CLI and this site's machine-readable surface
- [Compare](https://usectrl.dev/compare/) — honest feature matrix against the alternatives
- [Changelog](https://usectrl.dev/changelog) — what shipped, newest first
- [Source code](https://github.com/SamuelAlev/control-center) — MIT-licensed

---
Canonical page: https://usectrl.dev/