Run a fleet
without losing the room.

01Install / pick your path.

Clayrune ships two ways. Both reach the same dashboard at http://localhost:5199.

Windows — the .exe

1. Download MissionControl-Windows.zip from the latest release.
2. Unzip anywhere — Desktop, Documents, wherever.
3. Double-click MissionControl.exe.

A native window opens with the full dashboard. On first launch, the app installs the Claude CLI automatically if it's not already on your system.

macOS · Linux · WSL — from source

$ git clone https://github.com/ronle/mission-control.git
$ cd mission-control
$ pip install -r requirements.txt

# native window via pywebview
$ python app.py

# or browser-only
$ python server.py
$ open http://localhost:5199

02First run / the walkthrough.

Open the dashboard with zero projects and Clayrune auto-launches a guided 18-step tour. It uses a virtual demo tile and modal so you can poke around without affecting any real work.

You can re-trigger the tour any time from the Tour button in the header. Skip it whenever — every step is also documented below.

03Configuration / one JSON file.

On first run, Clayrune writes config.json at the project root with sensible defaults:

// config.json
{
  "port": 5199,
  "shared_rules_path": "data/SHARED_RULES.md",
  "projects_base": "/home/you",
  "agent_model": "",
  "agent_max_turns": 0,
  "use_streaming_agent": false,
  "user_name": "",
  "agent_name": ""
}

04Projects & tiles.

Each project gets a tile on the home grid. Tiles snap to a grid, drag freely, leave gaps, swap places. Status indicators (Active · Waiting · Blocked · Parked) live on every tile and tint the border. Domains group projects loosely and own their own accent color.

• Filter by status or domain — the rest of the grid dims.
• Compact button removes empty cells and tightens the layout.
• Activity stream across all projects sits at the bottom of the dashboard.
• Per-project accent color propagates into the project modal and agent tabs.

05Agents / dispatch & stream.

Open a project, type a task, hit dispatch. The agent spawns as a subprocess of claude and streams its output back over Server-Sent Events. Follow-ups go straight into the running session.

Two modes

• Mode A · per-turn (default) — Spawns a new claude process per turn. Follow-ups queue and auto-dispatch when the current turn finishes.
• Mode B · streaming — Set use_streaming_agent: true. The process stays alive between turns and follow-ups write directly to stdin. Faster, longer-lived sessions.

What's on screen

• Live elapsed timer for the running session.
• Per-session token usage and cost badge.
• Plan-mode button when an agent calls ExitPlanMode.
• Interactive forms when an agent calls AskUserQuestion.
• Paste screenshots directly into the input — Clayrune handles the upload.
• Multiple concurrent agent sessions per project, addressable as tabs.

06Backlog / what to tackle next.

Every project carries its own backlog with four priorities — critical, high, normal, low. Drag to reorder. Attach files via drag-and-drop. Dispatch any item straight to an agent session.

Backlog rows can sync bidirectionally with GitHub Issues — see § 09.

07Scheduler / runs while you sleep.

Schedule any project task to dispatch automatically. Three schedule types cover ~everything:

• Once — a specific datetime.
• Daily — a time, optionally constrained to weekdays.
• Interval — every N minutes.

The header banner shows the next five upcoming jobs at all times. Toggle individual schedules on or off without deleting them.

08Skills / procedures you reuse.

Skills are reusable agent procedures — playbooks, templates, repeatable workflows. Browse them per project, import them from other projects you own, share them across the fleet.

The skill broker lets you search for a skill that might apply to your current task — including skills authored in other projects your session can't normally see.

09Memory / a MEMORY.md per project.

Each project owns a MEMORY.md file. It's read into every agent prompt automatically, so the agent inherits your conventions, prior decisions, and don't-touch list across runs.

Session summaries can be appended on completion (auto-memory), so the file builds up over time. The same file is used by the bare claude CLI — Clayrune doesn't fork the format.

10GitHub Issues / bidirectional sync.

Wire any project to a GitHub repo via owner/repo. Backlog items mirror to Issues; Issues mirror back. Priorities map onto labels (high, medium, low). Open/closed status stays synchronized.

Sync runs every 5 minutes by default, or whenever you click the manual sync button. Authentication piggybacks on your local gh CLI — no token entry inside Clayrune.

11Phone tunnel / clayrune.io.

The clayrune.io tunnel exposes your local dashboard at a stable URL so you can drive the fleet from your phone. Encrypted handshake to your laptop. No router config. No port-forwarding.

Real use case: deploy from your laptop, board a flight, get into the airport, tap Restart server on your phone after the post-deploy worker crashes.

12Architecture / how it's wired.

Clayrune is deliberately small. One Flask process. One index.html. JSON on disk. subprocess spawns the claude CLI. No database. No framework. No build step.

┌──────────────────────────────────────────────────────────┐
│  YOUR DEVICE  ───  laptop · phone via clayrune.io tunnel │
├──────────────────────────────────────────────────────────┤
│  ┌─ static/index.html  → vanilla JS, no build           │
│  │   tile board · multi-window · stream viewer          │
│  │   SSE client · plan modal · tour engine              │
│  └──── ↑↓ HTTP + Server-Sent Events ────┐               │
│                                          │               │
│  ┌─ server.py  (Flask · port 5199)       │               │
│  │   REST API · SSE streams · static     │               │
│  │   github_sync.py (bidir issue sync)   │               │
│  └─── subprocess.Popen ──┐                │               │
│                          │                │               │
│  ┌─ claude (CLI subprocess)                              │
│  │   --output-format stream-json                         │
│  │   mode A: per-turn  |  mode B: persistent stdin      │
│  └─── reads / writes ──→  data/projects/*.json          │
│                            data/uploads/*               │
│                            data/SHARED_RULES.md         │
└──────────────────────────────────────────────────────────┘

The desktop window is pywebview wrapping the Flask server on Windows; the Windows installer is a Tauri v2 shell signed for distribution. Either way the dashboard is identical to http://localhost:5199.

13Data layout / what's on disk.

mission-control/
  app.py              ← desktop entry point (pywebview + Flask)
  server.py           ← Flask backend (API + static serving)
  github_sync.py      ← GitHub Issues sync module
  static/
    index.html        ← single-page app (HTML + CSS + JS)
  data/
    projects/         ← project JSON files (auto-created)
    uploads/          ← file attachments
    SHARED_RULES.md   ← injected into every agent run
  config.json         ← user configuration (gitignored)
  build.spec          ← PyInstaller spec
  installer.iss       ← Inno Setup installer (Windows)

Everything Clayrune knows about your fleet lives in data/projects/. Each file is human-readable JSON; backups and diffs are trivial.

14Contributing / carve a rune.

The entire frontend is one HTML file. The server is one Python file. The data is one folder of JSON. Forging a new feature requires no build pipeline — open static/index.html, edit, refresh.

1. Fork the repo on GitHub.
2. Create a branch: git checkout -b feature/my-feature.
3. Edit. Refresh. Test against python server.py.
4. Open a pull request — describe the why, not just the what.

Want to wire up a new connector (Linear, Notion, Slack)? The Flask backend is small and friendly — most connectors land in under 200 lines.