# Control Center

> Control Center (usectrl.dev) is a free and open-source developer operations deck: dispatch AI coding agents across isolated copy-on-write Git worktrees, review and merge their pull requests, and run the surrounding operation — tickets, pipelines, meetings, calendar, memory, a code graph — in one native app. Self-hosted cc_server with desktop (macOS/Windows/Linux), web and phone clients; multiplayer for humans and agents; MIT-licensed.

## Product

- [Landing page](https://usectrl.dev/): what the deck is, the four pillars, the platform under the hood, downloads.
- [Compare Control Center](https://usectrl.dev/compare/): feature matrix and starting prices against Conductor, Superset, Orca, Paperclip, Multica, OpenClaw, Hermes Agent, Goose and Cursor.
- [Changelog](https://usectrl.dev/changelog/): newest first; latest is v0.0.1-rc.1 — Control Center takes off (Sep 10, 2026).
- [Control Center vs Conductor](https://usectrl.dev/compare/conductor/): Conductor and Control Center both run parallel agents in isolated worktrees on a Mac — they diverge at everything around the fleet. Conductor is the smoother, simpler start; Control Center is the whole operation: review and merge, tickets, pipelines, meetings, multiplayer and a server you actually host.
- [Control Center vs Superset](https://usectrl.dev/compare/superset/): Superset and Control Center share the worktree-first model of parallel agents — Superset as a lean agent dashboard, Control Center as the whole operation. Superset maximizes raw parallelism; Control Center wraps the fleet in review, tickets, pipelines and meetings on one self-hosted server.
- [Control Center vs Orca](https://usectrl.dev/compare/orca/): Orca is the closest tool to Control Center here: both are MIT-licensed, ship desktop on all three platforms plus phone companions, isolate every task in a real worktree, and review and merge pull requests in-app. They diverge on scope — Orca is an agent IDE, Control Center is the operation deck around it: tickets with Linear sync, DAG pipelines, meetings and calendar, memory, guardrails and human multiplayer on a server that owns the state.
- [Control Center vs Paperclip](https://usectrl.dev/compare/paperclip/): Paperclip and Control Center both organize AI agents into something bigger than a chat window — Paperclip into a company (org chart, budgets, goals), Control Center into a developer operation (review, tickets, pipelines, meetings). Paperclip is the better business metaphor; Control Center is the better software workflow.
- [Control Center vs Multica](https://usectrl.dev/compare/multica/): Multica and Control Center both make agents teammates — Multica through project management (assign issues, track progress), Control Center through the full developer operation. Multica is the cleaner PM surface; Control Center is where the assigned work actually runs, reviews and merges.
- [Control Center vs OpenClaw](https://usectrl.dev/compare/openclaw/): OpenClaw and Control Center both run on a server you own, and that is where the resemblance ends. OpenClaw is a general-purpose personal assistant you reach from WhatsApp; Control Center is a developer operations deck — parallel coding agents in git worktrees, PR review and merge, tickets, pipelines and meetings. Pick OpenClaw for life admin over chat; pick Control Center for the software operation.
- [Control Center vs Hermes Agent](https://usectrl.dev/compare/hermes/): Hermes Agent and Control Center are not competing for the same job: Hermes is a self-improving personal assistant reachable from chat, Control Center is a developer operations deck for a fleet of coding agents. Pick Hermes if you want one agent that learns you; pick Control Center when the work is a repository — worktrees, review, tickets, pipelines.
- [Control Center vs Goose](https://usectrl.dev/compare/goose/): Goose and Control Center solve different sizes of the same problem: Goose is one excellent extensible agent, Control Center runs many — including Goose itself, via its runner adapters. Pick Goose for a single teachable pair-programmer; pick Control Center when one agent becomes a fleet.
- [Control Center vs Cursor](https://usectrl.dev/compare/cursor/): Cursor and Control Center split the developer stack: Cursor is the AI-first editor you write code in, Control Center is the operation you run agents from — and it opens any PR straight into Cursor on its worktree. Keep both; they do different jobs.
- [RSS feed](https://usectrl.dev/rss.xml) and [llms-full.txt](https://usectrl.dev/llms-full.txt): this whole site as one file.

## When to use this

Reach for Control Center when the job is:

- Running several AI coding agents at once on one repo — each agent gets its own copy-on-write worktree, OS-native sandbox and budget, so parallel runs never trip over each other.
- Reviewing and merging what agents ship — a PR review cockpit with AI reviewers (P0–P3 findings, ship/hold/block verdicts) across GitHub, GitLab and Bitbucket.
- Automating the operation around agents — DAG pipelines on cron or domain events, tickets with two-way Linear sync, delegation with budget inheritance and autonomy ceilings.
- Giving an agent a machine to test in — disposable desktop, browser and Android VMs (rigs) that a human can watch live and take over.
- Running a shared human+agent workspace — roles, presence, long-term memory and steer/take-over/hand-back on any run.

It is the wrong tool when you want a single in-editor pair-programmer (that is Cursor/Goose territory — see the compare pages) or a hosted SaaS you never operate.

If you are an agent reading this: this site is the documentation, not the product. The product is the self-hosted `cc_server`; once installed it exposes 103 typed MCP tools at `http://127.0.0.1:9030/mcp` (see the MCP server guide below). To read this site, prefer markdown: send `Accept: text/markdown` on any page URL, append `.md` to the path, or call the docs MCP server.

## Developer resources

- [Developers portal](https://usectrl.dev/developers): quickstart, product MCP server, CLI, containers and this site's agent endpoints.
- [OpenAPI document](https://usectrl.dev/openapi.json): OpenAPI 3.1 for this site's endpoints — typed responses, unique operation ids, error envelopes.
- [API catalog](https://usectrl.dev/.well-known/api-catalog): RFC 9727 linkset naming every API on this origin and its description, docs and metadata. Every page links to it with `rel="api-catalog"`.
- [MCP server card](https://usectrl.dev/.well-known/mcp/server-card.json): SEP-2127 card for the docs MCP server — identity, remotes and protocol versions.
- [Agent skills index](https://usectrl.dev/.well-known/agent-skills/index.json): published SKILL.md artifacts, each with a SHA-256 digest over the exact bytes served. Fetch, hash, compare before trusting one.
- [Docs MCP server](https://usectrl.dev/.well-known/mcp): Streamable HTTP MCP over this site's content (tools: list_pages, get_page_markdown, search_pages). Also at https://usectrl.dev/mcp.
- [MCP tools reference](https://usectrl.dev/manual/reference/mcp-tools/): the product's full 103-tool catalog.
- [cc_server CLI](https://usectrl.dev/manual/reference/cc-server-cli/): every flag, environment variable and subcommand of the headless server.
- [Source code](https://github.com/SamuelAlev/control-center): MIT-licensed monorepo (app, server, worker, clients, this site).

## Docs — Start here

- [Introduction](https://usectrl.dev/manual/): Control Center is the cockpit for multi-agent software development.
- [Concepts](https://usectrl.dev/manual/concepts/): How Control Center works and why it is built this way — the background reading behind the guides.
- [How-to guides](https://usectrl.dev/manual/guides/): Task-oriented recipes — pick the goal you have and follow the steps.
- [Install](https://usectrl.dev/manual/install/): Use Control Center in the browser or install the desktop app, set up an agent backend and choose where its server runs.
- [Quick start](https://usectrl.dev/manual/quick-start/): Install Control Center, configure one agent and watch it work on your repo.
- [Reference](https://usectrl.dev/manual/reference/): Complete, factual catalogs — routes, tools, events, shortcuts, enums and terms.
- [Tutorials](https://usectrl.dev/manual/tutorials/): Guided, start-to-finish lessons that take you through Control Center's main surfaces for the first time.

## Docs — Concepts

- [The agent model](https://usectrl.dev/manual/concepts/agent-model/): What an agent actually is in Control Center, which of its fields change behaviour and how the adapter it runs on decides what can be enforced.
- [AI review](https://usectrl.dev/manual/concepts/ai-review/): How a pull request becomes a reviewed one — review spaces, review nodes and peer consensus, cohorts and axes, the Ship/Hold/Block verdict, and why publishing stays a step you take.
- [Architecture](https://usectrl.dev/manual/concepts/architecture/): How Control Center is structured with a thin-client server model, feature-first Clean Architecture and ports and adapters.
- [Authorization — who may do what, and how you prove it](https://usectrl.dev/manual/concepts/authorization/): The permission catalog behind Control Center's roles, the tamper-evident audit trail every authorization decision lands in, and the install-wide controls an operator can pin.
- [Calendar and scheduling](https://usectrl.dev/manual/concepts/calendar/): How Control Center syncs Google Calendar on the server, why sign-in is a device-code grant and what the read-only scope means for RSVP.
- [Chat bridges](https://usectrl.dev/manual/concepts/chat-bridges/): Why the Slack integration dials out instead of listening, what actually authorizes a message that arrives from chat and how one bridge serves any chat product.
- [Code intelligence](https://usectrl.dev/manual/concepts/code-intelligence/): Why an agent needs the compiler, a structural matcher and a debugger — and what each one answers that the others cannot.
- [Conversation history](https://usectrl.dev/manual/concepts/conversation-history/): How a run keeps, folds, branches and resumes its context — compaction strategies, the session tree, and what "resume" actually means.
- [Deployment and clients](https://usectrl.dev/manual/concepts/deployment/): How Control Center's thin-client architecture splits a headless server from its desktop, web and mobile clients.
- [Agent dispatch lifecycle](https://usectrl.dev/manual/concepts/dispatch-lifecycle/): What happens between a message arriving and a run log closing — prompt assembly, worktrees, identity, what bounds a run and how its outcome is recorded honestly.
- [Domain events](https://usectrl.dev/manual/concepts/domain-events/): Why features talk through an in-process event bus instead of importing each other, what the bus is and is not the source of truth for and which events can actually drive automation.
- [Evals, replay and regression protection](https://usectrl.dev/manual/concepts/evals-replay/): The designed model for recording, replaying and grading agent runs — and an honest account of how little of it runs today.
- [Guardrails — one policy for every mutating action](https://usectrl.dev/manual/concepts/guardrails/): Why Control Center routes every agent side effect through a single allow/prompt/deny engine, how the ActionClass taxonomy stays small on purpose and what the autonomy dial really changes.
- [Meetings and transcription](https://usectrl.dev/manual/concepts/meetings/): How Control Center records a call, transcribes and diarizes it on the server and where the one step that leaves the host is.
- [Memory and knowledge](https://usectrl.dev/manual/concepts/memory-knowledge/): How Control Center stores agent knowledge, what actually reaches an agent's prompt and why memory reads are fail-open.
- [Modes](https://usectrl.dev/manual/concepts/modes/): Why a space, not an agent, carries a mode; what each of the four modes guarantees; and where that guarantee is structural rather than merely prompted.
- [Multiplayer — identity, membership and presence](https://usectrl.dev/manual/concepts/multiplayer/): How Control Center models humans and agents as co-equal participants, what actually gates access to a workspace and why live awareness and shared records travel on two different lanes.
- [Orchestration](https://usectrl.dev/manual/concepts/orchestration/): How one "big ask" becomes a whole-team plan you approve once, then a generated pipeline that runs it.
- [Pipelines and automation](https://usectrl.dev/manual/concepts/pipelines/): Why pipelines separate scheduling from work, what actually starts one and which of the built-in templates are live out of the box.
- [PR conversations](https://usectrl.dev/manual/concepts/pr-conversations/): How a GitHub PR comment becomes an agent turn with no webhook, what authorizes the author, and who each side of the conversation is attributed to.
- [Remote control and mobile](https://usectrl.dev/manual/concepts/remote-control/): How the phone reaches your server over a brokered, end-to-end-sealed relay rather than a peer-to-peer link and the layered access model that keeps that reach narrow.
- [Rigs and enclosures](https://usectrl.dev/manual/concepts/rigs/): Why agents get disposable VMs instead of your machine — the isolation model, the two display lanes, credentials, ports and the machine lifecycle.
- [Sandbox and security](https://usectrl.dev/manual/concepts/sandbox-security/): What actually constrains an agent in Control Center today, how far the OS sandbox reaches and which boundaries hold on a host that has no backend.
- [Single sign-on](https://usectrl.dev/manual/concepts/sso/): How SAML and OIDC logins work, what they verify and how accounts stay safe.
- [Tickets and delegation](https://usectrl.dev/manual/concepts/tickets/): Why a ticket tracks work without dispatching it, how delegation is guarded and what the vendor mirror does and does not own.
- [Tool context and prompt caching](https://usectrl.dev/manual/concepts/tool-context/): Why an agent is shown a small set of tools rather than all of them, how it reaches the rest, and the rules that keep the provider's prompt cache warm across a run.
- [Workspaces and isolation](https://usectrl.dev/manual/concepts/workspaces/): Why a workspace is a hard tenant boundary, how the database split makes that boundary structural and what deliberately crosses it.

## Docs — Guides

- [Manage adapters and models](https://usectrl.dev/manual/guides/adapters/): Connect model providers, pick the model an agent runs on and check which agent runner CLIs the server host has.
- [Add repos to a workspace](https://usectrl.dev/manual/guides/add-repos/): Register Git checkouts into a workspace so agents can work on them.
- [Diagnose an agent](https://usectrl.dev/manual/guides/agent-diagnostics/): Work through the run log, adapter probe, server status and host diagnostics when an agent stops producing runs.
- [Use AI-powered review](https://usectrl.dev/manual/guides/ai-review/): Run the pr_review pipeline on a PR, read the findings and verdict, then publish the review to GitHub.
- [Manage API keys](https://usectrl.dev/manual/guides/api-keys/): Where each credential lives — your user account on the server, the server itself, or an external CLI — and how to set, rotate and remove it.
- [Back up and restore](https://usectrl.dev/manual/guides/back-up-and-restore/): Take a snapshot of the install, move a workspace between machines, restore one workspace or all of them, and keep copies somewhere else.
- [Branch a conversation](https://usectrl.dev/manual/guides/branch-a-conversation/): Try a different approach from an earlier point without losing the one you already have, then fork or export what you want to keep.
- [Build an agent team](https://usectrl.dev/manual/guides/build-team/): Group agents under a leader so assigned work routes through one coordinator.
- [Chat with an agent](https://usectrl.dev/manual/guides/chat-with-agent/): Create a space with an agent, send it work, steer it mid-run and stop it.
- [Search code with the code graph](https://usectrl.dev/manual/guides/code-search/): Index a repo and use the code-graph tools to find symbols and see what a change would break.
- [Configure guardrails](https://usectrl.dev/manual/guides/configure-guardrails/): Set allow, ask-first and deny rules for agent actions, test them with the what-if probe and tune per-space autonomy.
- [Connect a Google Calendar](https://usectrl.dev/manual/guides/connect-calendar/): Connect Google Calendar to a workspace, manage multiple accounts and reconnect when a token expires.
- [Connect a code host](https://usectrl.dev/manual/guides/connect-forges/): Connect GitHub, GitLab or Bitbucket so the PR surface, repo registration and agent runs work — one workspace can use all three.
- [Connect to a remote server](https://usectrl.dev/manual/guides/connect-remote-server/): Point the desktop app or the web client at a cc_server running somewhere else and switch between servers without restarting.
- [Create and configure an agent](https://usectrl.dev/manual/guides/create-agent/): Add an agent to a workspace, give it an adapter, model, skills and permissions and confirm it runs.
- [Create a pipeline template](https://usectrl.dev/manual/guides/create-pipeline/): Author a DAG workflow template in the pipeline editor — add nodes, wire them, declare inputs and make it runnable.
- [Customize the chat bot](https://usectrl.dev/manual/guides/customize-chat-bot/): Rename the bot, reword what it says about itself, or change its slash command from Control Center.
- [Debug a failing test with an agent](https://usectrl.dev/manual/guides/debug-a-failing-test/): Have an agent set a breakpoint, launch under a debugger and read a real stack frame instead of adding print statements.
- [Delegate work to agents](https://usectrl.dev/manual/guides/delegate-tickets/): Hand a ticket to an agent in a conversation and let agents delegate sub-tasks to each other under the depth and cycle guards.
- [Direct background workers](https://usectrl.dev/manual/guides/direct-background-workers/): Use vibe mode to stop doing the work yourself and start directing several agents that do it in parallel.
- [Dispatch reviewer agents](https://usectrl.dev/manual/guides/dispatch-reviewers/): Send specialist reviewer agents at a PR from the PR view, an MCP tool, or a pipeline step.
- [Explore data in a persistent kernel](https://usectrl.dev/manual/guides/explore-data-in-a-kernel/): Give an agent a Python or JavaScript interpreter that keeps its variables between calls, draws charts into the chat, and can call your own tools from inside a cell.
- [Use focus mode and soundscapes](https://usectrl.dev/manual/guides/focus-mode/): Run a timed focus session with a floating countdown pill and suppressed notifications, and shape the adaptive soundscape that plays under it.
- [Create the GitHub App](https://usectrl.dev/manual/guides/github-app/): Register a GitHub App for your server so members can sign in, and so background work runs as the app rather than as a person.
- [Set up GitHub integration](https://usectrl.dev/manual/guides/github-integration/): Sign in to GitHub so the PR surface, repo registration and agent runs work.
- [Talk to Control Center from a GitHub PR](https://usectrl.dev/manual/guides/github-pr-conversations/): Ask the server's GitHub App bot for a review or a question from the PR conversation itself, with no webhook or public URL.
- [Set up Linear integration](https://usectrl.dev/manual/guides/linear-integration/): What exists of the Linear ticket sync today, why there is no in-app way to turn it on and what to do instead.
- [Link your Slack account](https://usectrl.dev/manual/guides/link-chat-account/): Prove that a Slack identity is yours so agents act on your messages and your work is attributed to you.
- [Manage costs](https://usectrl.dev/manual/guides/manage-costs/): See what your agents are spending, cap an autonomous run and cut token use.
- [Manage workspace memory](https://usectrl.dev/manual/guides/manage-memory/): Review, correct and prune the facts and policies agents have written into a workspace.
- [Install and manage skills](https://usectrl.dev/manual/guides/manage-skills/): Add GitHub repositories as skill sources, browse their catalogs, and install, update or uninstall skills through the antivirus scan gate.
- [Create and manage tickets](https://usectrl.dev/manual/guides/manage-tickets/): Create tickets, move them through their lifecycle, label and link them and record who owns what.
- [Use the MCP server](https://usectrl.dev/manual/guides/mcp-server/): Point an external MCP client at Control Center's tool server, set a bearer token and know what the surface exposes.
- [@-mention agents](https://usectrl.dev/manual/guides/mention-agents/): Mention agents in a space to dispatch them and teammates to notify them.
- [Monitor pipeline runs](https://usectrl.dev/manual/guides/monitor-pipelines/): Work the runs queue, read a run's waterfall and step panel and recover from a failed or stuck step.
- [Curate your newsfeed](https://usectrl.dev/manual/guides/newsfeed/): Add and manage RSS/Atom feeds, read articles with content blocking and know that your feeds follow you across every workspace.
- [Configure notifications](https://usectrl.dev/manual/guides/notifications/): Turn categories on or off, set quiet hours and a sound and know which notifications reach you where.
- [Pair a device](https://usectrl.dev/manual/guides/pair-a-device/): Pair your phone (or a second browser or desktop) with your Control Center server so you can follow the fleet remotely.
- [Run agents in parallel](https://usectrl.dev/manual/guides/parallel-agents/): Dispatch several agents at once and keep their work from colliding.
- [Set up pipeline triggers](https://usectrl.dev/manual/guides/pipeline-triggers/): Wire a template to start on a domain event, a schedule, or an inbound webhook — from the Trigger node in the template editor.
- [Use plan mode](https://usectrl.dev/manual/guides/plan-mode/): Switch a space into plan mode, get a typed plan and approve it into running work.
- [Work in Plan Studio](https://usectrl.dev/manual/guides/plan-studio/): Review, edit, estimate, diff and approve a plan in the Plan Studio editor and run parameterized playbooks.
- [Organize work with projects](https://usectrl.dev/manual/guides/projects/): Group tickets into projects from the sidebar, track progress and archive a project when it is done.
- [Record and summarize a meeting](https://usectrl.dev/manual/guides/record-meeting/): Record a call, get a transcript and turn it into notes, action items and decisions.
- [Repo scripts](https://usectrl.dev/manual/guides/repo-scripts/): Per-repository setup and archive scripts that run against a space's worktree.
- [Review and merge a PR](https://usectrl.dev/manual/guides/review-merge-pr/): Open a PR workbench, read the diff, leave inline comments, submit a review and merge.
- [Review Studio (cohorts, axes and deterministic diffs)](https://usectrl.dev/manual/guides/review-studio/): What the review compute pass produces server-side — cohorts, API-contract and visual diffs, per-axis gates — and why none of it has a viewer today.
- [Run a fleet worker](https://usectrl.dev/manual/guides/run-fleet-worker/): Build, pair and run the cc_worker headless executor so it registers with a cc_server and appears in the fleet panel.
- [Run a headless server](https://usectrl.dev/manual/guides/run-headless-server/): Run the cc_server headless binary or its Docker image, pair a client to it and configure it with the full CLI flag and environment surface.
- [Run an orchestration](https://usectrl.dev/manual/guides/run-orchestration/): Ask an orchestrator for a plan, review and edit it in Plan Studio, approve it once and let a generated pipeline do the work.
- [Run a pipeline manually](https://usectrl.dev/manual/guides/run-pipeline/): Start a pipeline run from the launcher, fill in its inputs and land on the run detail.
- [Configure sandbox policies](https://usectrl.dev/manual/guides/sandbox-policies/): What constrains an agent run, how to tell whether the OS sandbox is wrapping it and which capability settings the server actually reads.
- [Set up Slack integration](https://usectrl.dev/manual/guides/slack-integration/): Connect a Slack app to a Control Center workspace so members can drive agents from Slack.
- [Use spaces](https://usectrl.dev/manual/guides/spaces/): Create spaces, set their mode, manage participants and autonomy and open conversations and threads.
- [Connect an OpenID Connect provider](https://usectrl.dev/manual/guides/sso-oidc/): Wire any OIDC issuer — Pocket ID, Keycloak, Auth0, Zitadel — to Control Center sign-in.
- [Provision users with SCIM](https://usectrl.dev/manual/guides/sso-scim/): Let your IdP create, update and deprovision Control Center accounts automatically.
- [Refactor code structurally](https://usectrl.dev/manual/guides/structural-refactor/): Have an agent find and rewrite code by shape rather than by text, and review the change before it lands.
- [Triage your inbox](https://usectrl.dev/manual/guides/triage-inbox/): Work the unified inbox — clear what blocks you, review what waits on you and track your own PRs.
- [Tune an agent's tool context](https://usectrl.dev/manual/guides/tune-tool-context/): Inspect what a run actually sends, change which tools load up front, and work out whether a poor tool choice was a retrieval miss or a prompt problem.
- [Give an agent a machine to test on](https://usectrl.dev/manual/guides/use-rigs/): Rigs are disposable VMs an agent drives to test a browser, a desktop or a phone — watched live, and you can take the controls at any time.
- [Forward ports from an enclosed terminal](https://usectrl.dev/manual/guides/vm-ports/): Reach a dev server running inside a Terminal (VM) — from your machine, from the Browser (VM), on your network, or under a dev domain with HTTPS.

## Docs — Tutorials

- [Dispatch your first agent](https://usectrl.dev/manual/tutorials/first-agent/): Create an agent, give it a space and a task and watch the run stream back.
- [Bridge Slack to your workspace](https://usectrl.dev/manual/tutorials/first-chat-bridge/): Create the Slack app, connect it, link your account and get an agent answering in a Slack thread.
- [Build your first pipeline](https://usectrl.dev/manual/tutorials/first-pipeline/): Create a pipeline template, configure its step, allow manual runs and start one.
- [Review your first pull request](https://usectrl.dev/manual/tutorials/first-pr/): Open a PR in the workbench, read the diff, comment, approve and merge.
- [Your first workspace](https://usectrl.dev/manual/tutorials/first-workspace/): Create a workspace, register a repo into it and see the isolation boundary for yourself.
- [Sign your team in with SSO](https://usectrl.dev/manual/tutorials/sso/): Connect Okta (SAML) to your Control Center server and take a login end to end.

## Docs — Reference

- [Agent configuration](https://usectrl.dev/manual/reference/agent-configuration/): Every field on the agent entity, the enums it uses and which persisted fields have no effect.
- [Built-in agent tools](https://usectrl.dev/manual/reference/agent-tools/): The tool surface the built-in harness gives an agent — language server, structural search, debugger, kernels and worker control — with every operation and its arguments.
- [Backup, export and import](https://usectrl.dev/manual/reference/backup/): The snapshot layout, the manifest, every backup operation and transfer route, and exactly which files a backup does and does not contain.
- [cc_server CLI](https://usectrl.dev/manual/reference/cc-server-cli/): Every flag, environment variable, subcommand and data-directory path of the headless server.
- [Chat bridge](https://usectrl.dev/manual/reference/chat-bridge/): Providers, commands, credentials, capabilities, RPC operations and storage for the chat bridge.
- [Domain events](https://usectrl.dev/manual/reference/domain-events/): Complete catalog of the 53 domain events, their payloads and the server-side subscribers that consume them.
- [Glossary](https://usectrl.dev/manual/reference/glossary/): Definitions of key terms used throughout Control Center.
- [Keyboard shortcuts](https://usectrl.dev/manual/reference/keyboard-shortcuts/): The complete keybinding registry, by scope, with the conditions each shortcut fires under.
- [MCP tools](https://usectrl.dev/manual/reference/mcp-tools/): Complete catalog of the MCP tools cc_server registers, by family.
- [Pipeline steps](https://usectrl.dev/manual/reference/pipeline-steps/): Reference for pipeline step kinds, step body keys, their configuration and step results.
- [Rigs](https://usectrl.dev/manual/reference/rigs/): Every rig surface, backend, action verb, lifecycle state, port, default and contract — the complete factual catalog.
- [Route map](https://usectrl.dev/manual/reference/route-map/): Every route Control Center registers, with its screen and query parameters.
- [Sandbox backends](https://usectrl.dev/manual/reference/sandbox-backends/): The sandbox backends, where they are applied and every value object the sandbox runtime uses.
- [Slash commands](https://usectrl.dev/manual/reference/slash-commands/): Every command you can type in the composer, what it does and where it runs.
- [SSO configuration reference](https://usectrl.dev/manual/reference/sso/): Every knob, endpoint, op and error code of single sign-on.
- [Ticket lifecycle](https://usectrl.dev/manual/reference/ticket-lifecycle/): Ticket fields, statuses, transitions, relations and the mutation chokepoint.