01Install / pick your path.
Clayrune ships two ways. Both reach the same dashboard at http://localhost:5199.
Windows: one PowerShell line
# Installs the Claude CLI, clones Clayrune, adds a Desktop # shortcut, and opens the dashboard, no manual steps. PS> iwr https://clayrune.io/install.ps1 -useb | iex
Prefer a double-click? Grab Clayrune-Installer.exe and run it. It runs the exact same script. It's unsigned, so Windows shows an "unrecognized app" prompt once: click More info → Run anyway.
macOS · Linux · WSL: one line
# Sets up Node + the Claude CLI, clones Clayrune to ~/Clayrune, # creates a launcher, and opens the dashboard. $ curl -sSL https://clayrune.io/install.sh | sh
Any platform: 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
claude CLI signed into your Anthropic account. It never touches your API key directly. Every agent call goes through the local CLI.
02First run / the walkthrough.
Open the dashboard with zero projects and Clayrune auto-launches a short guided tour. It uses a virtual demo tile and modal so you can poke around without affecting any real work, walking you through the sidebar, header, a sample project, the agent console, Hivemind, the scheduler, and the Claydo guide.
You can re-trigger the tour any time from the ? button in the header or the command palette (Ctrl/⌘ + K). Skip it whenever. Every step is also documented below.
03Projects & 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.
04Agents / 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 B · streaming (default). The
claudeprocess stays alive between turns and follow-ups write directly to stdin. Faster, longer-lived sessions. - Mode A · per-turn. Set
use_streaming_agent: false. Spawns a newclaudeprocess per turn; follow-ups queue and auto-dispatch when the current turn finishes.
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.
05Hivemind / many agents, one goal.
Hand Clayrune a single goal and it spins up a coordinated multi-agent run. An orchestrator decomposes the goal into workstreams, then spawns worker agents, up to a concurrency cap you set, to tackle them in parallel.
- Orchestrator + workers: pick a model for each. The orchestrator plans and reviews; workers execute one workstream apiece.
- Shared knowledge: workers publish findings, decisions, and a running synthesis to a common layer so they don't duplicate each other.
- Message bus: workers post and poll messages to coordinate mid-run.
- Handoffs & review: each workstream submits a handoff document before it closes; you can intervene, approve decisions, or escalate questions back to yourself.
Every hivemind's state lives under data/hiveminds/, so a run survives restarts and stays inspectable.
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 section 13.
07Scheduler / runs while you sleep.
Schedule any project task to dispatch automatically. Five schedule types cover ~everything:
- Once: a specific datetime.
- Daily: a time, optionally constrained to weekdays.
- Weekly: a time on chosen days of the week.
- Interval: every N minutes.
- Cron: a raw cron expression for anything more exotic.
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.
09MCP servers / extend the agents.
Clayrune manages Model Context Protocol servers, the connectors that give your agents extra tools (filesystem, databases, web, your own services). Add, edit, and remove them from the UI; Clayrune owns the underlying config so you never hand-edit JSON.
- Global servers live in
~/.claude.jsonand apply to every project. - Per-project servers live in the project's
.mcp.jsonand shadow a global server of the same name at session start. - Install from a URL: paste a remote MCP endpoint and Clayrune previews its metadata before wiring it up.
The same servers are visible to the bare claude CLI. Clayrune doesn't fork the format, it just gives you a panel to manage it.
10Memory / 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.
11Learning / the fleet gets sharper.
Clayrune watches how your agents actually work and turns the wins into reusable assets, so the same hard-won lesson never has to be learned twice.
- Skill distiller: a background loop reviews completed sessions for a repeatable pattern, a fix, a workflow, a gotcha, and proposes a new skill from it. Proposals land for your review; nothing is installed behind your back.
- Memory that compounds: session summaries fold back into each project's MEMORY.md, so conventions, decisions, and don't-touch lists carry forward across runs.
- Cross-project reuse: a lesson distilled in one project can be brokered into another, so the whole fleet benefits, not just the project that learned it.
The effect is cumulative: the more you run, the more Clayrune already knows about how you work, and the less you have to re-explain.
12Process manager / nothing runs unseen.
Agents spawn things: dev servers, bots, watchers, long-running scripts. Clayrune keeps a registry of every background process an agent starts, so you always know what's alive and can stop it from the dashboard.
- Registered on spawn: each process records its PID, a label, and the command that launched it.
- List & kill: see everything running across the fleet; kill any process by PID without hunting through a terminal.
- Cleanup: sweep dead PIDs from the registry in one click.
For long-running visual commands, agents can also open a terminal pop-out with full ANSI output, streamed straight into the dashboard.
13GitHub 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.
14Phone 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.
15Architecture / 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.
16Data layout / what's on disk.
mission-control/
app.py ← desktop entry point (pywebview + Flask)
server.py ← Flask backend (API + static serving)
agent_runtime.py ← spawns / streams the claude CLI
github_sync.py ← GitHub Issues sync module
skills.py ← skills system
mcp.py ← MCP server management
distiller.py ← learning loop (proposes skills)
static/
index.html ← single-page app (HTML + CSS + JS)
data/
projects/ ← project JSON files (auto-created)
uploads/ ← file attachments
memory/ ← per-project MEMORY.md files
skills/ ← skill definitions
mcp/ ← MCP server configs
hiveminds/ ← multi-agent run state
SHARED_RULES.md ← injected into every agent run
config.json ← user configuration
installer/ ← install.ps1 · install.sh · Clayrune-Installer.exe
src-tauri/ ← Tauri desktop shell (Windows build)
Everything Clayrune knows about your fleet lives in data/projects/. Each file is human-readable JSON; backups and diffs are trivial.
17Contributing / 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.
- Fork the repo on GitHub.
- Create a branch:
git checkout -b feature/my-feature. - Edit. Refresh. Test against
python server.py. - 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.