# Control Center

> Multi-agent development cockpit: isolated worktrees, PR review, GitHub/Linear, all native.

- **Type:** MCP server
- **Install:** `agentstack add mcp-samuelalev-control-center`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [SamuelAlev](https://agentstack.voostack.com/s/samuelalev)
- **Installs:** 0
- **Category:** [Developer Tools](https://agentstack.voostack.com/c/developer-tools)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [SamuelAlev](https://github.com/SamuelAlev)
- **Source:** https://github.com/SamuelAlev/control-center
- **Website:** https://usectrl.dev/

## Install

```sh
agentstack add mcp-samuelalev-control-center
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# Control Center

**The cockpit for multi-agent software development.**

Spawn and direct autonomous coding agents, watch their work unfold in real time,
and review and merge what they ship, from one quiet, well-instrumented deck.

[](#install)
[](https://flutter.dev)
[](#works-with-the-tools-you-already-run)
[](#)
[](https://usectrl.dev/manual)
[](LICENSE)

[Features](#features) · [Install](#install) · [How it works](#how-it-works) · [Documentation](https://usectrl.dev/manual)

---

Control Center gives you command over a fleet of AI coding agents. Each agent runs
on its own branch, in its own copy-on-write worktree, producing pull requests, logs,
costs, and messages in parallel, all behind a native desktop app with GitHub and
Linear integration.

> **Spawning ten agents is easy. Knowing which one needs you isn't.** Git, your
> terminal, and the GitHub UI were built for one person writing one branch. The hard
> part was never any single action. It's holding the whole fleet in view at once,
> seeing what's blocked or waiting on you, and acting in one or two moves without
> losing the thread. That's what Control Center is for.

> [!NOTE]
> Control Center ships as a native desktop build, **available today on macOS**.
> Windows and Linux are close behind.

## Features

### Drive the fleet from a message

Messaging is the primary way to use agents. Open a channel or @-mention an agent in a
channel and it dispatches into its own worktree, thinking, tool calls, and
output streaming back in real time.

- Channels with threads and @-mentions
- Agents that ask a question render inline as a form and route your answer back
- Review channels, plan mode, and parallel dispatch from one room

[Chat with an agent →](https://usectrl.dev/manual/guides/chat-with-agent/) · [Channels →](https://usectrl.dev/manual/guides/channels/)

### Follow the fleet from your phone

Pair your phone with **[Remote](https://remote.usectrl.dev/)** over a direct,
peer-to-peer link and keep up from anywhere, read messages, reply, triage
tickets, without the desktop's data ever leaving it.

- WebRTC peer-to-peer with QR pairing; no cloud relay sees your data
- A read-mostly companion: default-deny tools, per-workspace scoping
- Switch workspaces on the phone without touching the desktop

[Remote control and mobile →](https://usectrl.dev/manual/concepts/remote-control/) · [Pair a device →](https://usectrl.dev/manual/guides/pair-a-device/)

### See the whole fleet at a glance

Thinking, running, blocked, failed, idle. Every agent's state reads at a glance.
Presence reports real work, never decoration.

- Live status and presence for every agent and run
- Per-run token cost and last-output age, rolled up
- Ownership and attribution stay legible, solo or team

[The agent model →](https://usectrl.dev/manual/concepts/agent-model/)

### Review and merge what the fleet ships

Priority pull requests surface first. Read the diff, comment, dispatch reviewer
agents, and land a ship / hold / block verdict, without leaving the deck.

- Built-in diff viewer with syntax highlighting and inline threads
- Inline comments and suggested edits that sync back to GitHub
- AI reviewers with P0–P3 findings and a rolled-up verdict

[Review and merge a PR →](https://usectrl.dev/manual/guides/review-merge-pr/)

### Orchestrate the work as a pipeline

Compose steps into a DAG, prompt an agent, run a script, fan out reviewers, join
the results. Every node carries its own retry and continue-on-fail policy.

- Router and join nodes for conditional, parallel work
- Triggers: manual, scheduled (cron), or off a domain event
- Resumable runs with per-run cost and token totals
- Or hand the goal to an agent. It proposes a whole-team plan, you approve once, and a pipeline runs it

[Pipelines →](https://usectrl.dev/manual/concepts/pipelines/)

### One ticket, from request to merge

The single unit of work the whole fleet shares, vendor-agnostic, synced with
Linear both ways, and coupled to the pipeline that delivers it.

- Bidirectional Linear sync: status, assignee, comments
- Coupled to a pipeline run that drives the work end to end
- An execution lock, one owner at a time, never a double-claim

[Tickets →](https://usectrl.dev/manual/concepts/tickets/)

### Isolated by default, open by design

Every channel runs over copy-on-write worktrees inside an OS-native sandbox,
with credentials minted per launch and revoked on teardown.

- Seatbelt (macOS) / bubblewrap (Linux) with capability controls
- Secrets brokered in memory, never written to disk
- 70+ typed tools over MCP / JSON-RPC for any client

[Sandbox security →](https://usectrl.dev/manual/concepts/sandbox-security/) · [MCP server →](https://usectrl.dev/manual/guides/mcp-server/)

### Knowledge that compounds across runs

Each run opens with more context, and you keep more control, than the run
before it.

- Memory: facts, policies, domains over a hybrid FTS + vector graph
- Role-gated reads, no agent sees beyond its scope
- Code graph: tree-sitter callers, callees, and impact radius

[Memory & knowledge →](https://usectrl.dev/manual/concepts/memory-knowledge/) · [Code search →](https://usectrl.dev/manual/guides/code-search/)

### Capture meetings as notes

Record a call and walk away with a clean writeup. Audio is captured, transcribed,
and summarized entirely on-device. Nothing leaves the machine.

- System + microphone capture with on-device Whisper transcription
- Speaker diarization, then an AI summary with action items and decisions
- Action items link straight to tickets; notes stay local and private

[Meetings →](https://usectrl.dev/manual/concepts/meetings/)

### A calendar that knows your fleet

Connect Google Calendar, see your day, and turn any event into a
recorded, summarized meeting in one click.

- Per-workspace Google sign-in, event sync, and RSVP to invitations
- Month, week, and agenda views with "meeting starting soon" alerts
- Start a recording seeded from an event and link it back

[Calendar →](https://usectrl.dev/manual/concepts/calendar/)

## Works with the tools you already run

| Integration | What it does |
|---|---|
| **GitHub** | Pull requests, reviews, inline comments, checks, and user profiles |
| **Linear** | Bidirectional ticket sync: status, assignee, and comments |
| **Google Calendar** | Per-workspace event sync, RSVP, "starting soon" alerts, and record-and-link |
| **MCP** | 70+ typed tools over JSON-RPC, callable by any MCP client, plus a client that bridges in external MCP servers |
| **Agent runtimes** | A built-in agent runtime (direct provider API), plus Claude Code, Codex, and Pi auto-detected on your `PATH`, and any ACP-compatible runner |
| **[Remote](https://remote.usectrl.dev/)** | The phone companion over WebRTC: messages, replies, and ticket triage from anywhere |

---

## Install

### macOS

```bash
brew tap control-center/tap
brew install --cask control-center
```

Or download the latest `.dmg` (Apple Silicon) from
[Releases](https://github.com/SamuelAlev/control-center/releases/latest).

Free and open source · auto-updates · macOS 13 or later.

> [!IMPORTANT]
> Before your first run you'll need **Git**, an **agent runtime** (either the built-in
> runtime with a model-provider API key, or an agent CLI like Claude Code, Codex, or Pi
> that Control Center detects on your `PATH`), and a **GitHub personal access token** with
> repo and PR permissions, or the `gh` CLI, which Control Center detects automatically.
> Tokens are stored in your system keychain, never on disk.

### Build from source

Requires the [Flutter](https://docs.flutter.dev/get-started/install) SDK (desktop enabled).

```bash
flutter pub get
flutter pub run build_runner build --delete-conflicting-outputs
flutter gen-l10n
flutter run -d macos   # or windows, linux
```

> [!IMPORTANT]
> **macOS contributors, sign with your own Apple team for secure storage to work.**
> Credentials live in the macOS *data-protection keychain*, which requires the app to be
> signed by an Apple Developer team (a **free** Apple ID works for local dev). The debug
> entitlement uses `$(DEVELOPMENT_TEAM)`, so you don't edit any source, just run, once:
>
> ```bash
> # add your Apple ID in Xcode → Settings → Accounts first, then:
> bash macos/scripts/create_local_signing_cert.sh
> ```
>
> It writes a git-ignored `Signing.local.xcconfig` set up for **automatic signing** under your
> team. Because the app uses the Keychain Sharing capability, mint the development provisioning
> profile once (`flutter run` can't, it doesn't pass `-allowProvisioningUpdates`):
>
> ```bash
> flutter build macos --config-only
> xcodebuild -workspace macos/Runner.xcworkspace -scheme Runner \
>   -configuration Debug -allowProvisioningUpdates build
> ```
>
> Then `flutter run -d macos` works (the script prints these commands too). An unsigned/no-team
> build still launches, but secure storage (GitHub/Linear/Google login) is unavailable until you
> sign. Windows/Linux need no signing to run locally.

## How it works

1. **Create a workspace**, your top-level container for agents, repos, channels, and
   memory. The first workspace seeds a CEO agent that can hire and coordinate others.
2. **Add repositories**, each agent channel gets its own copy-on-write worktree
   branch, so agents work in parallel without ever touching your source checkout.
3. **Dispatch an agent**, mention `@agent` in a channel. It gets an isolated worktree,
   a prompt assembled from its role, persona, skills, and context, runs in a
   capability-gated sandbox, and streams its thinking and output back in real time.
4. **Review and merge**, when the agent finishes it opens a pull request. Review the
   diff and merge, all without leaving the app.

Every channel runs in one of four **modes** (`chat`, `plan`, `review`, or
`orchestrate`), each gating the system prompt, whether the agent can write files, and
which tools it can reach.

> [!TIP]
> The whole surface (agents, review, the code graph, memory, and ticketing) is exposed
> over an MCP / JSON-RPC server. Point any MCP client at it and drive Control Center the
> same way the app drives itself.

---

## Documentation

| Resource | What's there |
|---|---|
| [usectrl.dev/manual](https://usectrl.dev/manual) | The full manual: tutorials, guides, concepts, and reference |
| [Quick start](https://usectrl.dev/manual/quick-start/) | Zero to your first dispatched agent in five minutes |
| [ARCH.md](ARCH.md) | Architecture, layering, and the technology stack |
| [GLOSSARY.md](GLOSSARY.md) | The ubiquitous-language glossary for the domain |

## Built with

Flutter (desktop), Riverpod, Drift (SQLite with FTS5 + vector search), go_router,
a token-based Material 3 base theme under the in-repo cc_ui design system, dio
(GitHub, Linear & Google Calendar), tree-sitter, on-device Whisper transcription
with speaker diarization, and an MCP / JSON-RPC tool server.
See [ARCH.md](ARCH.md) for the full picture.

## Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [SamuelAlev](https://github.com/SamuelAlev)
- **Source:** [SamuelAlev/control-center](https://github.com/SamuelAlev/control-center)
- **License:** MIT
- **Homepage:** https://usectrl.dev/

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/mcp-samuelalev-control-center
- Seller: https://agentstack.voostack.com/s/samuelalev
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.