Bring tickets, code reviews, AI agents, meetings and pipelines together. Control Center
is a free, open-source developer workspace for desktop, web and phone. Agents are one
part of the desk, not a prerequisite for using the rest.
One server owns the databases, credentials, external APIs and agent execution. The
desktop app, the browser and a paired phone all render that same server-owned
workspace.
Features
Parallel agents
Give each task an isolated Git worktree. Follow the run, steer an agent or take over
without disturbing the rest.
Run agents in parallel →
Approve a push before it runs
Put Git pushes, PR publishing and other guarded actions behind an approval. Review what
the agent is about to do before it changes anything. No approver connected? The action
is denied. Your server enforces permissions, not a prompt.
Configure action approvals →
Pull request review
Read diffs with discussions and checks alongside. Add an AI review when it helps, then
publish with your own forge account.
Review a pull request →
Connected tickets
Sync Linear, set priorities and assign the work. Link the ticket to the conversation
where it gets done.
Manage tickets →
Meeting notes
Record and transcribe on your server. Keep the decisions and action items after the
call ends.
Record a meeting →
Repeatable pipelines
Build a workflow once. Run it on a schedule, from an event or by hand, and inspect every
step.
Build a pipeline →
Account switching
Choose the accounts each agent can use, then rotate across them without losing the
run's context.
Manage model providers →
Usage quota
Check provider allowance and reset times before starting the next run.
Manage costs →
Observability
Follow live agents and inspect run costs, token use and latency in your workspace.
Inspect agent runs →
Skill and agent editors
Edit workspace skills and configure each agent's model, instructions and permissions. Run paired skill evaluations, inspect per-attempt evidence in Quality, and opt into revision-triggered reevaluation.
Manage skills →
Evaluate a skill →
Soundscapes and focus
Run a timed focus session, quiet notifications and shape the soundscape playing under
it. Focus, relax, sleep and rise moods follow the time of day and the weather.
Use focus mode →
Your desk is a place. Your work isn't.
The smaller pieces, sorted by where you are when the work needs you.
At your desk
One inbox
Reviews, approvals and blockers wait in a single queue. The command palette takes you
to the next one.
Plan Studio
Ask for a plan in orchestrate mode and get proposed roles, child tickets and steps.
Nobody is hired until you approve.
Newsfeed
A personal RSS reader. It stays yours, outside the shared workspace.
Away from it
Your phone
Pair it once, then follow runs and answer approvals from anywhere. The phone shows the
work; the server does it.
Any browser
The same app at app.usectrl.dev, connected to a server you run.
A Slack thread
Mention the bot and an agent picks up the work in its own worktree. You follow it
without leaving the thread.
Bring the tools you already work with
Connected through your server, not another copy of your day. Each connection, by what
comes in and what goes back out:
| Connection | Comes in | Goes out |
|---|
| GitHub · GitLab · Bitbucket Cloud | Pull requests, diffs, checks and deployment previews | Reviews and comments, published under your own account |
| Linear | Tickets with their status, assignee and comments | The same fields, synced back |
| Slack | A mention in a bridged thread | The live run, then the answer, posted in that thread |
| Google Calendar | Your events | RSVPs, where the calendar grants write access |
| Agent runtimes | Tool calls and output from the built-in runtime, Claude Code, Codex, Pi or any ACP runner | A prompt and an isolated worktree for every run |
| MCP | Tools from external MCP servers, for your agents to use | Control Center itself, as typed tools for any MCP client |
One workspace can mix repos from all three code hosts; each repo's forge is read from its
origin.
Connect a code host → · Connect Slack → · MCP server →
How it works
Work moves between tools. Its context should come along.
- Start with the ticket. Set the priority, name the owner and link the
conversation. The ticket keeps the record.
- Give the work its own space. Discuss a plan, prepare an isolated worktree and run
the agent. Steer or take over when you need to.
- Bring the result into review. Read the changes, follow the discussion and publish
with your forge account. The story stays connected.
Agents run on the server, or on optional fleet workers that take leased jobs without
holding the database, credentials or budgets. Each conversation's worktree is a
copy-on-write clone on macOS and Linux and a plain git worktree on Windows, so an agent
never writes to your source checkout.
Every conversation runs under one of three profiles: propose only, act with
approval or act freely. Permissions, a sandbox and budgets still bound what it can
do. Soft budgets warn, hard budgets pause the agent and every run keeps a log.
Read the architecture guide → · Sandbox security →
End-to-end encrypted on every connection
Desktop, web and phone encrypt session content between your paired device and your
Control Center server, whether connected directly or through the relay. RPC,
terminal input/output, editor traffic, attachments and backup transfers use the same
authenticated encrypted channel. The relay forwards ciphertext it cannot decrypt;
server identity pins reject an unexpected server.
Encryption is mandatory. Update the server and clients together:
older clients and plaintext resource requests are rejected. Your server remains a
trusted endpoint, and configured agents and model providers can read the content you
send them. This does not encrypt stored databases or backups, or hide connection
metadata.
Security and trust boundaries
Install
Make yourself at home. Your next developer day can start here, free and open source.
| Surface | Get it | Notes |
|---|
| macOS | Apple Silicon .dmg | macOS 13+. Signed and notarized. Intel Macs build from source |
| Windows | x64 installer | Windows 10+. A portable .zip is on the releases page |
| Linux | x86_64 AppImage | glibc 2.35+ and GTK 3 (Ubuntu 22.04+). Also a .tar.gz |
| Web | app.usectrl.dev | Same app, nothing to install. Encrypted connection to your server |
| Phone | remote.usectrl.dev | Encrypted direct or relayed connection to your server |
Every build is on GitHub Releases,
along with standalone cc_server archives for all three platforms. cc-server,
cc-webapp and cc-remote container images are published to GHCR. The desktop app
updates itself.
Prefer to host it yourself? A browser tab can't be the server, so the web app always
talks to one you run. Start cc_server locally and connect to ws://localhost:9030,
which browsers trust without a certificate, or reach a server on another machine over
wss:// through TLS, a reverse proxy, a VPN or a tunnel. See
Run a headless server.
Try it first. The live demo opens the web app on a
furnished workspace with invented data and scripted agents. No account, no install. It
runs cc_demo_server, the real server with the
executing half removed, so it can show a fleet without being able to run anything.
[!IMPORTANT]
Before your first run you need Git, an agent runtime (the built-in runtime with
a model-provider API key, or an agent CLI such as Claude Code, Codex or Pi on your
PATH) and a code host: GitHub, GitLab or Bitbucket Cloud. Credentials live on the
server, attached to your user account, never in the client, so a phone or browser tab
never holds a token.
Build from source
Requires the Flutter SDK (desktop enabled).
scripts/natives/build_natives.sh # required — a missing native is a hard boot failure
fvm flutter pub get
fvm flutter pub run build_runner build --delete-conflicting-outputs
fvm flutter gen-l10n
fvm flutter run -d macos # or windows, linux
The SDK is pinned with fvm, so prefix every Flutter/Dart command with
fvm. Native libraries are required and have no degraded mode: build them first or
cc_server refuses to boot and names the offender.
Windows and Linux need nothing further. On macOS, secure storage (the client's device
pairing keys) needs the app signed by an Apple team. A free Apple ID is enough and it
is a one-time setup: see Local development signing
in RELEASING.md. Everything else runs unsigned.
Good questions
No. Control Center puts tickets, pull requests, conversations, meetings, calendar,
pipelines, agents and a personal RSS reader in one workspace. Agents are one part of the
desk, not a prerequisite for using the others.
A ticket records the work and its status; execution happens in a conversation. The
conversation can provision an isolated copy-on-write worktree before an agent run. On
Windows, provisioning uses a Git worktree.
No. Orchestrate can research and propose roles, child tickets and a plan, but hiring
waits for approval. Plan Studio opens from the plan row in the originating conversation;
a ticket assignment alone does not start a run.
The paired phone is a thin client for the same server-backed workspace, not a second
execution host. Desktop, browser and phone show the same operation; agents execute on
the server or on optional leased fleet workers.
The live transcript can separate speakers while recording. After you stop, the
summarizer processes the meeting and stores its notes, decisions and action items;
recording and processing are distinct states.
The public demo is a separate, locked-down build with invented data and scripted agents.
Its records and runs are examples, not your own work.
Documentation
| Resource | What's there |
|---|
| usectrl.dev/manual | The full manual: tutorials, guides, concepts and reference |
| Quick start | Zero to your first dispatched agent in five minutes |
| Changelog | What shipped, release by release |
| ARCH.md | Architecture, layering and the technology stack |
| SECURITY.md | Authorization, credentials and network boundaries |
| RELEASING.md | Packaging, signing and the release pipeline |
| GLOSSARY.md | The ubiquitous-language glossary for the domain |
Community and support
License
Control Center is free and open source under the MIT License. Built in the open.
