Skip to content
Back to search

mission-control

Open-source task management for the agentic era. The command center for solo entrepreneurs who delegate work to AI agents.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/meisnerdan--mission-control/badge.svg)](/listings/meisnerdan--mission-control)

HTML

<a href="/listings/meisnerdan--mission-control"><img src="/api/listings/meisnerdan--mission-control/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Prerequisites

| Requirement | Why | Install | |-------------|-----|---------| | [Node.js](https://nodejs.org) v20+ | Runtime | [nodejs.org](https://nodejs.org) | | [pnpm](https://pnpm.io) v9+ | Package manager | `npm install -g pnpm` | | [Claude Code](https://docs.anthropic.com/en/docs/claude-code) *(recommended)* | Agent automation (Launch button, daemon, slash commands) | `npm install -g @anthropic-ai/claude-code` |

> The web UI works standalone for task management, prioritization, and goal tracking. Claude Code is needed to **execute** tasks via agents. Any AI coding tool that can access local files (Cursor, Windsurf, etc.) can also participate — see [Works With](#works-with) below.

Install & Run

git clone https://github.com/MeisnerDan/mission-control.git
cd mission-control/mission-control   # repo folder → app folder (where package.json lives)
pnpm install
pnpm dev

# Always-on mode (optional, auto-restarts on crash)
pm2 start ecosystem.config.js

Open [http://localhost:3000](http://localhost:3000) and click **"Load Demo Data"** to see it in action with sample tasks, agents, and messages.

What to Try First

1. **Explore the dashboard** — see task counts, agent workloads, and recent activity at a glance 2. **Drag tasks** on the Priority Matrix — move tasks between Do, Schedule, Delegate, and Eliminate 3. **Click a task card** to open the detail panel — edit description, subtasks, and acceptance criteria 4. **Click the 🚀 Launch button** on a task assigned to an agent — spawns a Claude Code session that executes the work (requires Claude Code) 5. **Open Claude Code in this workspace** and run `/daily-plan` to see slash commands in action

---

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 447 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <p align="center">
  2. <a href="https://github.com/MeisnerDan/mission-control/stargazers"><img src="https://img.shields.io/github/stars/MeisnerDan/mission-control?style=social" alt="GitHub Stars" /></a>&nbsp;
  3. <img src="https://img.shields.io/github/license/MeisnerDan/mission-control" alt="License" />&nbsp;
  4. <img src="https://img.shields.io/badge/version-0.10-blue" alt="Version" />&nbsp;
  5. <a href="https://github.com/MeisnerDan/mission-control/actions"><img src="https://img.shields.io/github/actions/workflow/status/MeisnerDan/mission-control/ci.yml?label=build" alt="Build Status" /></a>
  6. </p>
  7. <p align="center">
  8. <img src="mission-control/docs/rocket.svg" alt="Mission Control Rocket" width="80" />
  9. </p>
  10. <h1 align="center">Mission Control</h1>
  11. <p align="center">
  12. <strong>Tame the swarm. Ship what matters.</strong><br/>
  13. Open-source command center for solo entrepreneurs who delegate work to AI agents.
  14. </p>
  15. <p align="center"><img src="mission-control/docs/demo.gif" alt="Mission Control Demo" width="800" /></p>
  16. <div align="center">
  17. <br/>
  18. **Idea** · · · **Research** · · · **Go / No-Go** · · · **Build MVP** · · · **Launch**
  19. You jot down a raw idea. Agents research the market and deliver a go/no-go report.<br/>
  20. You give the green light. Agents build the MVP. You review it and say ship it.<br/><br/>
  21. **They deploy the app, post to social media, run ad campaigns,<br/>set up payments, and keep it running.**<br/>
  22. You made three decisions. They did everything else.
  23. <br/>
  24. </div>
  25. ---
  26. ## Why This Exists
  27. Right now, everyone is releasing autonomous AI agents into the wild. It's a Cambrian explosion — agent swarms spinning up, executing tasks, calling APIs, moving money, posting content. It's exhilarating. It's also like herding wild horses. Powerful, untamed, and running in every direction. Credentials are leaking. Agents are operating as black boxes. Nobody can tell you what's actually running, whether it finished, or if it went off the rails three hours ago.
  28. I'm a serial entrepreneur with way more ideas than hours in the day, and nowhere near enough resources to pursue them all traditionally. I built Mission Control because I was drowning — not in work, but in the *chaos* of trying to manage it all. I wanted my time back. Time with my family. Time actually living — not trading my finite heartbeats for a paycheck. AI agents are the greatest force multiplier a solo founder has ever had. But unleashing baby AGIs into the wild without structure? That's not leverage. That's a liability.
  29. **Mission Control is the fenced playground where your AI agents can run wild — but safely.** It's the bridge between you and your swarm. Agents get roles, inboxes, and reporting protocols. You capture a raw idea in the brain dump, agents research it, build the MVP, and Field Ops launches it into the world — with approval workflows and spend limits at every step. You stay in control without micromanaging. You see everything. You ship what matters.
  30. <table>
  31. <tr>
  32. <td align="center" width="25%">
  33. **Prioritize**
  34. Eisenhower matrix tells you what matters. Drag-and-drop tasks between Do, Schedule, Delegate, and Eliminate.
  35. </td>
  36. <td align="center" width="25%">
  37. **Delegate**
  38. Assign tasks to AI agents. They pick up work, execute, and post completion reports to your inbox.
  39. </td>
  40. <td align="center" width="25%">
  41. **Supervise**
  42. Dashboard, inbox, decisions queue. See every agent's workload, read their reports, answer their questions.
  43. </td>
  44. <td align="center" width="25%">
  45. **Execute**
  46. Agents don't just manage tasks — they execute real-world actions. Post to X, send ETH, call APIs. With approval workflows and spend limits.
  47. </td>
  48. </tr>
  49. </table>
  50. > **How is this different from Linear, Asana, or Notion?** Those tools were built for humans typing into forms. Mission Control was built **agent-first** — from day one, for a world where AI agents do the work and humans make the decisions. Agents read and write tasks through a token-optimized API, report progress to your inbox, and escalate to you when they need judgment. You manage outcomes, not keystrokes. And it runs locally — no cloud dependency, no API keys leaked to third parties, no vendor lock-in.
  51. ---
  52. ## Features
  53. - **Eisenhower Matrix** — Prioritize by importance and urgency with drag-and-drop between quadrants
  54. - **Kanban Board** — Track work through Not Started, In Progress, and Done columns
  55. - **Goal Hierarchy** — Long-term goals with milestone tracking, progress bars, and linked tasks
  56. - **Brain Dump** — Capture ideas instantly, triage into tasks later
  57. - **Agent Crew** — 6 built-in agents + create unlimited custom agents with unique instructions
  58. - **Skills Library** — Define reusable knowledge modules and inject them into agent prompts
  59. - **Multi-Agent Tasks** — Assign a lead agent + collaborators for team-based work
  60. - **Orchestrator** — Run `/orchestrate` to spawn all agents on pending work simultaneously
  61. - **Autonomous Daemon** — Background process that automatically polls tasks, spawns Claude Code sessions, enforces concurrency, and provides a real-time dashboard
  62. - **One-Click Execution** — Press play on any task card to spawn a Claude Code session; live status indicators, success/failure toasts, and automatic completion (task → done, inbox report, activity log)
  63. - **Session Resilience** — Agents that timeout or hit max turns automatically re-spawn continuation sessions, preserving progress in task notes and subtasks. Configurable max continuations per task and per inbox response
  64. - **Cost & Usage Tracking** — Captures cost and full token usage (input, output, cache read, cache creation) from every Claude Code session; displayed on the Autopilot dashboard with per-task cost breakdown and running totals
  65. - **Failure Logging** — Failed tasks generate `task_failed` activity events with error details, session count, and agent info. Failure reports are automatically posted to your inbox
  66. - **Inbox Stop Button** — Stop an agent mid-response with a single click; kills the process tree and prevents continuation chains from spawning
  67. - **Continuous Missions** — Run an entire project with one click; tasks auto-dispatch as others complete, respect dependency chains, and skip decision-blocked work. Real-time progress bar with stop button
  68. - **Loop Detection** — Auto-detects agents stuck in failure loops; after 3 attempts, escalates to a user decision with options to retry differently, skip, or stop
  69. - **Token-Optimized API** — Filtered queries, sparse field selection, 92% context compression (~50 tokens vs ~5,400)
  70. - **Inbox & Decisions** — Full agent communication layer: delegation, reports, questions, and approvals
  71. - **Cmd+K Search** — Global search across tasks, projects, goals, and brain dump entries
  72. - **Error Resilience** — Error boundaries on every page with retry buttons, plus global error handler for crash recovery
  73. - **API Pagination** — All 9 GET endpoints support `limit` and `offset` with a `meta` object (total, filtered, returned)
  74. - **193 Automated Tests** — Vitest suite covering validation schemas, data layer operations, and full agent communication flow
  75. - **Skills Injection** — Skills from the library are embedded into agent command files bidirectionally (agent→skill and skill→agent)
  76. - **Accessibility** — ARIA live regions for drag-and-drop screen reader announcements, focus trapping on detail panels
  77. - **CI Pipeline** — GitHub Actions runs typecheck, lint, build, and tests on every push and PR
  78. ### Field Ops — External Action Execution
  79. - **64-Service Catalog** — Pre-configured services across 16 categories with setup guides
  80. - **3 Working Adapters** — X, Ethereum (+ MetaMask wallet signing), Reddit
  81. - **Encrypted Vault** — AES-256-GCM encryption with scrypt key derivation
  82. - **Financial Safety Controls** — Per-service + global spend limits, circuit breaker (master-password-protected)
  83. - **3 Autonomy Levels** — Manual Approval, Supervised, Full Autonomy
  84. - **Approval Workflows** — Risk classification + approval queue for high-risk actions
  85. - **Dry Run Testing** — Validate actions without executing + auto-staleness checks
  86. - **Mission System** — Group related tasks into missions with progress tracking
  87. - **Emergency Stop** — Kill switch that instantly halts daemon, pauses missions, and locks the vault
  88. - **PM2 Support** — Always-on mode with auto-restart on crash (ecosystem.config.js included)
  89. - **Master-Password-Protected Controls** — Autonomy levels, safety limits, and daemon launch require vault password
  90. - **Safety Dashboard** — Centralized per-service and global spend limits with circuit breaker
  91. <p align="center">
  92. <img src="mission-control/docs/screenshots/eisenhower.png" alt="Eisenhower Priority Matrix" width="400" />
  93. <img src="mission-control/docs/screenshots/kanban.png" alt="Kanban Status Board" width="400" />
  94. </p>
  95. <p align="center">
  96. <img src="mission-control/docs/screenshots/crew.png" alt="Agent Crew Management" width="400" />
  97. <img src="mission-control/docs/screenshots/inbox.png" alt="Agent Inbox" width="400" />
  98. </p>
  99. ---
  100. ## Quick Start
  101. ### Prerequisites
  102. | Requirement | Why | Install |
  103. |-------------|-----|---------|
  104. | [Node.js](https://nodejs.org) v20+ | Runtime | [nodejs.org](https://nodejs.org) |
  105. | [pnpm](https://pnpm.io) v9+ | Package manager | `npm install -g pnpm` |
  106. | [Claude Code](https://docs.anthropic.com/en/docs/claude-code) *(recommended)* | Agent automation (Launch button, daemon, slash commands) | `npm install -g @anthropic-ai/claude-code` |
  107. > The web UI works standalone for task management, prioritization, and goal tracking. Claude Code is needed to **execute** tasks via agents. Any AI coding tool that can access local files (Cursor, Windsurf, etc.) can also participate — see [Works With](#works-with) below.
  108. ### Install & Run
  109. ```bash
  110. git clone https://github.com/MeisnerDan/mission-control.git
  111. cd mission-control/mission-control # repo folder → app folder (where package.json lives)
  112. pnpm install
  113. pnpm dev
  114. # Always-on mode (optional, auto-restarts on crash)
  115. pm2 start ecosystem.config.js
  116. ```
  117. Open [http://localhost:3000](http://localhost:3000) and click **"Load Demo Data"** to see it in action with sample tasks, agents, and messages.
  118. ### What to Try First
  119. 1. **Explore the dashboard** — see task counts, agent workloads, and recent activity at a glance
  120. 2. **Drag tasks** on the Priority Matrix — move tasks between Do, Schedule, Delegate, and Eliminate
  121. 3. **Click a task card** to open the detail panel — edit description, subtasks, and acceptance criteria
  122. 4. **Click the 🚀 Launch button** on a task assigned to an agent — spawns a Claude Code session that executes the work (requires Claude Code)
  123. 5. **Open Claude Code in this workspace** and run `/daily-plan` to see slash commands in action
  124. ---
  125. ## How It Works
  126. Mission Control stores all data in local JSON files. No database, no cloud dependency. AI agents interact by reading and writing these files — the same source of truth the web UI uses.
  127. ### The Agent Loop
  128. ```
  129. 1. You create a task ──> Assign to an agent role (e.g., Researcher)
  130. 2. Press play (or daemon) ──> Spawns a Claude Code session with agent persona
  131. 3. Agent executes ──> Does the work, updates progress
  132. 4. Mission Control completes ──> Auto-marks done, posts report, logs activity
  133. 5. You review ──> Read reports in inbox, answer questions
  134. ```
  135. Multiple agents can work in parallel across different tasks. **Continuous missions** take this further — click the rocket button on a project to run all tasks until done. As each task completes, the next batch auto-dispatches, respecting dependency chains and concurrency limits. If an agent gets stuck, loop detection escalates to you after 3 failures. The **daemon** (`pnpm daemon:start`) adds 24/7 background automation, polling for new tasks and running scheduled commands on cron schedules.
  136. ### Testing
  137. Mission Control includes **193 automated tests** across 3 suites:
  138. ```bash
  139. pnpm test # Run all tests
  140. pnpm check # Typecheck + lint
  141. pnpm verify # Full verification: typecheck + lint + build + test
  142. ```
  143. | Suite | Tests | Covers |
  144. |-------|-------|--------|
  145. | **Validation** | 90 | All 17 Zod schemas — field defaults, constraints, edge cases |
  146. | **Daemon** | 42 | Security (credential scrubbing, path validation, binary whitelist), config loading, prompt builder, types |
  147. | **Data Layer** | 19 | Read/write operations, file I/O, mutex safety, archive |
  148. | **Agent Flow** | 17 | End-to-end: task creation → delegation → inbox → decisions → activity log |
  149. | **Security** | 25 | API auth, rate limiting, token/origin validation, CSRF protection |
  150. ---
  151. ## Agent API
  152. Every API endpoint is designed for minimal token consumption. Your agents spend tokens doing work, not parsing bloated payloads.
  153. ```bash
  154. # Get only your in-progress tasks (~50 tokens vs ~5,400 for everything)
  155. GET /api/tasks?assignedTo=developer&kanban=in-progress
  156. # Sparse fields — return only what you need
  157. GET /api/tasks?fields=id,title,kanban
  158. # Get just the DO quadrant (important + urgent)
  159. GET /api/tasks?quadrant=do
  160. # Paginated results with metadata
  161. GET /api/tasks?limit=10&offset=0
  162. # → { data: [...], meta: { total: 47, filtered: 47, returned: 10, limit: 10, offset: 0 } }
  163. # Compressed context — entire workspace state in ~650 tokens
  164. # (vs ~10,000+ for raw JSON files)
  165. pnpm gen:context # outputs data/ai-context.md
  166. ```
  167. ```bash
  168. # Run a single task — spawns a Claude Code session
  169. POST /api/tasks/:id/run
  170. # Run all eligible tasks in a project as a continuous mission
  171. POST /api/projects/:id/run
  172. # Stop a running mission (kills all processes, resets tasks)
  173. POST /api/projects/:id/stop
  174. # Stop a single running task
  175. POST /api/tasks/:id/stop
  176. # Get live status of all active runs
  177. GET /api/runs
  178. # Get mission status (with auto-reconciliation of stuck missions)
  179. GET /api/missions
  180. # Check status of inbox auto-respond sessions
  181. GET /api/inbox/respond/status?messageId=msg_123
  182. # Stop an active inbox auto-respond chain
  183. POST /api/inbox/respond/stop
  184. ```
  185. ### Field Ops API
  186. ```bash
  187. POST /api/field-ops/execute # Execute a field task
  188. POST /api/field-ops/vault/setup # Initialize encrypted vault
  189. GET /api/field-ops/catalog # Browse 64-service catalog
  190. POST /api/field-ops/batch # Bulk approve/reject up to 50 tasks
  191. GET /api/field-ops/safety-limits # Read spend limits and budgets
  192. PUT /api/field-ops/safety-limits # Update limits (requires master password)
  193. ```
  194. All write endpoints use **Zod validation** (malformed data returns field-level errors) and **async-mutex locking** (concurrent writes from multiple agents queue safely, never corrupt data).
  195. ---
  196. ## Built-In Agents
  197. | Role | Handles | Assign when... |
  198. |------|---------|----------------|
  199. | **Me** | Decisions, approvals, creative direction | Requires human judgment |
  200. | **Researcher** | Market research, competitive analysis, evaluation | Needs investigation |
  201. | **Developer** | Code, bug fixes, testing, deployment | Technical implementation |
  202. | **Marketer** | Copy, growth strategy, content, SEO | Marketing/content work |
  203. | **Business Analyst** | Strategy, planning, prioritization, financials | Analysis/strategy work |
  204. | **Tester** | QA testing, bug reporting, performance analysis | Needs verification/testing |
  205. | **+ Custom** | Anything you define | Create via `/crew/new` with custom instructions |
  206. Agents are fully editable — change their name, instructions, capabilities, and linked skills at any time through the Crew UI or by editing `data/agents.json` directly.
  207. ---
  208. ## Slash Commands
  209. Run these in any [Claude Code](https://docs.anthropic.com/en/docs/claude-code) session opened in this workspace:
  210. | Command | Purpose |
  211. |---------|---------|
  212. | `/standup` | Daily standup from git + tasks + inbox + activity |
  213. | `/daily-plan` | Top priorities + inbox check + decisions + brain dump triage |
  214. | `/weekly-review` | Accomplishments + goal progress + stale items |
  215. | `/orchestrate` | Coordinate all agents — spawn sub-agents for pending tasks |
  216. | `/brainstorm` | Generate creative ideas on a topic |
  217. | `/research` | Web research with structured markdown output |
  218. | `/plan-feature` | Break a feature into tasks + create milestone |
  219. | `/ship-feature` | Test, lint, commit + update task status + post report |
  220. | `/pick-up-work` | Check inbox for new assignments, pick highest priority |
  221. | `/report` | Post a status update or completion report |
  222. | `/researcher` | Activate researcher agent persona |
  223. | `/marketer` | Activate marketer agent persona |
  224. | `/business-analyst` | Activate business analyst persona |
  225. ### Daemon Commands
  226. ```bash
  227. pnpm daemon:start # Start the autonomous daemon (background process)
  228. pnpm daemon:stop # Stop the daemon gracefully
  229. pnpm daemon:status # Show daemon status, active sessions, and stats
  230. ```
  231. The daemon runs as a background Node.js process, polling `tasks.json` for pending work and spawning Claude Code sessions via `claude -p`. It enforces concurrency limits, retries failed tasks, and runs scheduled commands (daily-plan, standup, weekly-review) on cron schedules. Monitor everything from the `/daemon` dashboard.
  232. > **Note on authentication:** The daemon spawns Claude Code directly via `claude -p` — it does not extract or transmit OAuth tokens, make raw API calls, or use the Agent SDK. Your Claude account credentials stay within Claude Code's own authentication layer, the same as running `claude -p` from your terminal. This is local automation of an official Anthropic product, not a third-party integration.
  233. ---
  234. ## Architecture
  235. ```
  236. mission-control/ Next.js 15 web app (the visual interface)
  237. mission-control/data/ JSON data files (the shared source of truth)
  238. tasks.json Tasks with Eisenhower + Kanban + agent assignment
  239. goals.json Long-term goals and milestones
  240. projects.json Projects with team members
  241. agents.json Agent registry (profiles, instructions, capabilities)
  242. skills-library.json Reusable knowledge modules for agents
  243. inbox.json Agent <-> human messages and reports
  244. decisions.json Pending decisions requiring human judgment
  245. activity-log.json Timestamped event log of all activity
  246. ai-context.md Generated ~650-token workspace snapshot
  247. daemon-config.json Daemon configuration (schedule, concurrency, etc.)
  248. daemon-status.json Daemon runtime state (sessions, history, stats)
  249. missions.json Continuous mission state (progress, history, loop detection)
  250. active-runs.json Live task execution tracking (status, PIDs, errors)
  251. respond-runs.json Inbox auto-respond chain tracking (status, PIDs, cost)
  252. field-ops/ Field Ops data (tasks, missions, services, vault, activity)
  253. field-tasks.json External action tasks with approval state machine
  254. field-missions.json Mission groupings
  255. services.json Connected service configurations
  256. service-catalog.json 64 pre-configured service definitions
  257. safety-limits.json Spend limits + circuit breaker config
  258. approval-config.json Autonomy levels and risk thresholds
  259. templates.json Reusable task templates
  260. activity-log.json Field Ops audit trail
  261. mission-control/src/lib/adapters/ Service execution adapters (X, Ethereum, Reddit)
  262. mission-control/scripts/daemon/ Autonomous agent daemon (node-cron + claude -p)
  263. mission-control/__tests__/ Automated tests (validation, data, integration, daemon)
  264. .claude/commands/ Auto-generated slash commands per agent
  265. scripts/ Orchestration scripts (tmux parallel agents)
  266. docs/ Business plans and strategies
  267. ```
  268. ### Design Decisions
  269. - **Local-first** — No database, no cloud, no API keys. Your data stays on your machine in plain JSON files.
  270. - **JSON as IPC** — Humans (web UI) and agents (file reads + API) share the same source of truth. No sync layer needed.
  271. - **BYOAI** — Works with any agent that can read files: Claude Code, Cursor, Windsurf, or a custom script.
  272. - **Zod + Mutex** — All API writes are validated with Zod schemas and serialized with async-mutex to prevent data corruption during concurrent multi-agent operations.
  273. - **Defense in Depth** — Field Ops uses layered security: encrypted vault (AES-256-GCM + scrypt), per-service and global spend limits, autonomy levels, approval workflows, rate limiting, and master-password-protected safety controls. Agents cannot modify security settings.
  274. ### Works With
  275. Mission Control runs locally and integrates with AI coding tools through the filesystem and CLI:
  276. - **[Claude Code](https://docs.anthropic.com/en/docs/claude-code)** — Open this workspace in Claude Code to use slash commands (`/orchestrate`, `/daily-plan`, `/standup`, etc.) and let agents read/write task data directly.
  277. - **[Claude Cowork](https://docs.anthropic.com/en/docs/claude-cowork)** — Cowork agents can use Mission Control as a tool by reading the workspace's `CLAUDE.md` and JSON data files directly — no special plugin required.
  278. - **Any file-aware agent** — Cursor, Windsurf, or custom scripts can read the JSON data files and call the API endpoints to participate in the agent loop.
  279. ---
  280. ## Tech Stack
  281. | Layer | Technology |
  282. |-------|------------|
  283. | Framework | [Next.js 15](https://nextjs.org) (App Router) |
  284. | Language | [TypeScript](https://www.typescriptlang.org) (strict mode) |
  285. | Styling | [Tailwind CSS v3](https://tailwindcss.com) |
  286. | Components | [shadcn/ui](https://ui.shadcn.com) + [Radix UI](https://www.radix-ui.com) |
  287. | Drag & Drop | [@dnd-kit](https://dndkit.com) |
  288. | Validation | [Zod](https://zod.dev) |
  289. | Search | [cmdk](https://cmdk.paco.me) |
  290. | Testing | [Vitest](https://vitest.dev) |
  291. | Storage | Local JSON files (no database required) |
  292. ---
  293. ## Roadmap
  294. - [x] Screenshots and demo GIF for README
  295. - [x] One-click task execution with live status
  296. - [x] Continuous Missions (run entire projects)
  297. - [x] Loop detection with automatic escalation
  298. - [x] Session resilience (auto-continuing agents)
  299. - [x] Cost & usage tracking
  300. - [x] Field Ops — External action execution with approval workflows
  301. - [x] Encrypted credential vault (AES-256-GCM)
  302. - [x] Financial safety controls (spend limits, circuit breaker)
  303. - [x] 64-service catalog with setup guides
  304. - [ ] More adapters (Stripe, Slack, GitHub, SendGrid, etc.)
  305. - [ ] Audit log export (CSV/JSON for compliance)
  306. - [ ] GitHub Issues sync (import issues as MC tasks)
  307. - [ ] Mobile-friendly PWA version
  308. - [ ] Dashboard analytics (velocity charts, burndown, agent utilization)
  309. - [ ] Plugin system for custom integrations
  310. Mission Control already runs 24/7 locally with PM2 (`pm2 start ecosystem.config.js`). **Want a hosted version?** Star the repo — Mission Control Cloud is on the roadmap. The self-hosted version will always remain free and open source.
  311. See [open issues](https://github.com/MeisnerDan/mission-control/issues) for community-requested features and to vote on what matters most.
  312. ---
  313. ## Contributing
  314. Contributions are welcome! Whether it's bug fixes, new agent integrations, UX improvements, or documentation.
  315. 1. Fork the repo
  316. 2. Create a feature branch
  317. 3. Run `pnpm verify` — typecheck, lint, build, and tests must all pass
  318. 4. Submit a PR
  319. See **[CONTRIBUTING.md](CONTRIBUTING.md)** for detailed guidelines, code conventions, and architecture notes.
  320. ---
  321. ## Disclaimer
  322. I built this for myself — a solo entrepreneur trying to wrangle an ever-growing swarm of AI agents and side projects. I'm sharing it because I think others are drowning in the same chaos. It's provided **as-is**, no warranties or promises of support. Use it at your own risk. See the [LICENSE](LICENSE) file for full terms.
  323. Mission Control is not affiliated with or endorsed by Anthropic. It automates Claude Code (an official Anthropic product) via the `claude -p` CLI — it does not access the Anthropic API directly or use the Agent SDK.
  324. **A note on Field Ops:** These features execute real actions with real consequences — posting to social media, sending cryptocurrency, calling live APIs. Always test with dry runs first. Configure spend limits before enabling autonomy. The safety controls exist for a reason — use them.
  325. ---
  326. ## License
  327. [AGPL-3.0](LICENSE) — free to use, modify, and self-host. If you offer it as a hosted service, you must open-source your modifications under the same license.
  328. For commercial licensing (SaaS, white-label, or proprietary use without AGPL obligations), contact **dan@meisner.dev**.
  329. ---
  330. <p align="center">
  331. <sub><strong>Tame the swarm. Ship what matters.</strong></sub>
  332. </p>

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.