missiond

Lisp-governed local orchestration for Claude Code, Codex, Gemini, and MissionD workers— normalize requests, review intent and plans, dispatch BoardTasks to managed PTY slots, and close work from durable evidence.

MissionD is a daemon and tool surface that turns requests into reviewed Lisp artifacts, approved plans, BoardTasks, and worker execution. The V3 control-plane authority is.missiond/v3/missiond-blueprint.lisp; generated JSON under.missiond/v3/runtime/compiled/is the machine projection. Production runtime paths consume compiled JSON only; raw V3 Lisp source fallback is not a runtime escape hatch. Postgres is the runtime store, event log, and runtime artifact catalog; Board and PTY screens are projections over that state.

- PTY Sessions— Spawn Claude Code in pseudo-terminals with full terminal emulation (via Alacritty terminal)
- Semantic Parsing— Real-time state detection (Idle/Thinking/Responding/Confirming/Error), tool output extraction, status bar parsing, confirm dialog parsing
- MCP Integration— generated tool groups exposed through Model Context Protocol and the daemon IPC bridge
- Request/Plan Gates—mission_requestwrites request-local Lisp artifacts and requires explicit intent/plan approval before execution in human mode
- BoardTask Dispatch— approved plans route throughmission_task_delegate, Board claims, Autopilot, and managed PTY slots
- V3 Compiled Contracts—missiond-lispcemits source-hash checked runtime config, semantic IR, contract ABI, project universe, workflow contracts, and genome projections
- Permission System— Role-based tool permissions (allow/confirm/deny) with glob pattern matching
- Cross-Platform— macOS, Linux, Windows; Unix domain sockets or TCP loopback IPC

- Auto-Restart— Automatically restarts PTY slots when context window drops below 10%
- Stuck Detection— Monitors JSONL activity to detect and recover stuck agents
- Autonomous Workflow— Agents can work autonomously with safety guardrails and reporting back to the orchestrator

- Knowledge Base (KB)— Postgres-backed reviewed memory and FTS/read-model projections
- Runtime Artifact Catalog— cold.missiond/v3/runtime/files stay as diagnostic caches and are indexed inruntime_artifactsfor evidence views and retention governance
- Conversation Logging— Ingests provider-local logs into MissionD's Postgres read models and event stream
- Memory Extraction— Real-time and deep analysis pipelines that extract insights from agent conversations
- KB Injection— Automatically injects relevant knowledge into agent context via MCP server instructions and UserPromptSubmit hooks

- WebSocket API— Real-time PTY attach, task events, and session monitoring
- Board UI— Next.js dashboard with conversation viewer, slot status, and task management
- CC Tasks Watcher— Cross-session task monitoring by watching Claude Code's JSONL session files
- PTY Screenshots— Render terminal state as PNG images for visual debugging

- Mission Board— Task/kanban board with notes, hidden tasks, and skip status
- Question Queue— Agents can post questions for human review instead of blocking
- Slot History— Track task assignment history per slot
- AI Router— Route LLM requests through configurable model backends (for KB analysis)
- Reachability Check— Probe configured server health endpoints
- OS Diagnostics— System resource monitoring (CPU, memory, disk)

┌─────────────────┐ MCP ┌──────────────┐ │ Claude Code │◄────────────►│ mission-mcp │ │ (Orchestrator) │ └──────┬───────┘ └─────────────────┘ │ IPC (JSON-RPC) ▼ ┌──────────────────┐ │ missiond │ │ (Daemon) │ ├──────────────────┤ │ • Request/Plan │ │ • Board/EventBus │ │ • PTY Manager │ │ • Permission Mgr │ │ • Postgres Store │ │ • Knowledge Base │ │ • Memory Pipeline │ │ • WebSocket API │ │ • CC Tasks Watcher│ └────────┬─────────┘ │ PTY ┌─────────────────────────┼─────────────────────────┐ ▼ ▼ ▼ ┌───────────┐ ┌───────────┐ ┌───────────┐ │ slot-1 │ │ slot-2 │ │ slot-N │ │ Claude │ │ Claude │ │ Claude │ │ (coder) │ │ (research)│ │ (memory) │ └───────────┘ └───────────┘ └───────────┘

cargo install missiond-mcp --bin mission-mcp cargo install missiond-daemon --bin missiond cargo install missiond-attach --bin missiond-attach

{ "mcpServers": { "mission": { "command": "mission-mcp", "args": [], "env": { "MISSION_LOG_LEVEL": "warn" } } } }

slots: - id: coder-1 role: coder description: "Coding specialist" cwd: /path/to/projects - id: researcher-1 role: researcher description: "Research and documentation" cwd: /path/to/docs

User: "Spawn an agent to refactor the auth module" Claude: I'll spawn a coding agent for that task. [Uses mission_pty_spawn tool] [Uses mission_pty_send with the refactoring instructions]

- State Machine— Tracks Idle, Thinking, Responding, ToolRunning, Confirming, Error, SlashMenu states with debounce
- Confirm Dialog Parsing— Extracts tool name, parameters, file paths from permission prompts
- Status Bar Parsing— Reads spinner state and status text from bottom lines
- Tool Output Extraction— Parses both boxed (───) and inline tool outputs
- Title Parsing— Monitors terminal title changes for session info

pub enum SessionEvent { StateChange { new_state, prev_state }, ConfirmRequired { prompt, info }, StatusUpdate(ClaudeCodeStatus), ToolOutput(ClaudeCodeToolOutput), TitleChange(ClaudeCodeTitle), TextComplete(String), }

import { MissionControl } from '@missiond/core'; const mission = new MissionControl(); await mission.connect(); // Auto-starts daemon // Spawn PTY session const pty = await mission.pty.spawn('slot-1', 'claude'); pty.on('state', (state) => console.log('State:', state)); pty.on('confirm', (info) => console.log('Confirm:', info)); // Send message and wait for response const response = await pty.send('Explain this codebase'); console.log(response); await pty.kill(); mission.close();

- Unix(macOS/Linux): Unix domain sockets (~/.missiond/missiond.sock)
- Windows*: TCP loopback (127.0.0.1:port)

roles: coder: allow: - "Bash()" - "Read()" - "Write()" confirm: - "Edit()" deny: - "Bash(rm -rf)" researcher: allow: - "Read()" - "WebSearch()" deny: - "Bash()" - "Write()"

To usemission_kb_analyzeandmission_router_chat, configure an LLM backend in~/.missiond/credentials.json:

{ "auth_url": "https://your-llm-api-endpoint.com", "api_key": "your-api-key" }

Slot environment variables support${secret:path}syntax that resolves secrets at spawn time via a configurable command.

# Build all crates cargo build # Run daemon cargo run --bin missiond # Run MCP server cargo run --bin mission-mcp # Build Node.js packages cd packages/node-client && pnpm build cd packages/board && pnpm build

This is a web browser that enables your coding agent, such as Claude Code, to visit websites on your behalf and assist you in identifying bugs or creating UI test cases.

Agent-native developer Q&A API with MCP + A2A endpoints for citations, job pickup, and answer submission.

MCP bridge that lets Claude Code delegate heavy tasks to the Antigravity CLI (agy) — purpose-built tools, model routing with fallback, session continuity, and output truncation to save Claude's context and tokens.

Embeds intelligent guidance into AI workflows to organize development and ensure quality.

Open-source AI coding stack — bundled MCP servers, agent runtime, and developer tooling for shipping AI-native dev tools.

Local agent workbench bundling OpenHands, Goose, Aider, and ashlrcode against one local LLM, with ashlr-plugin MCP servers pre-wired.

Async Parallel Antigravity for Codex & Claude Code

Run parallel, resumable, human-operable Antigravity CLI sessions from Codex, Claude Code, or any MCP-capable agent harness.

knowledge network for AI coding agents. Developers connect their agents to a shared pool of verified solutions — saving tokens, reducing debugging time, and getting better results. Solution authors earn when their work helps others.

Orchestrates multiple Claude Code agents across iTerm2 sessions, providing centralized management and inter-agent communication.

An MCP server for multi-agent orchestration using Claude AI via Claude Desktop.

Multi-LLM Design and Build Team. Confer and create with a team of LLMs.