flowchart LR
    You([You]) -->|app · channel · call| Lead
    Lead -->|quick answer| Reply([Reply])
    Lead -->|does the work| Tools
    Lead -->|"escalate(to: team)"| Crew
    subgraph Crew [Crew round]
        direction TB
        Orchestrated["Orchestrated<br/>lead plans · specialists build"]
        Swarm["Swarm<br/>peers huddle · claim tasks"]
    end
    Crew --> Tools
    Tools["code · shell · browser · computer<br/>web · MCP · skills · plugins"] --> Log[(Append-only<br/>event log)]
    Crew --> Reviewer{Reviewer}
    Lead --> Reviewer
    Reviewer -->|findings| Crew
    Reviewer -->|passes| Reply
    Log --> UI[Live UI · replay · audit]

1. The work sizes itself. Every request goes to one lead with every tool. A question gets an answer, a script gets written by the lead alone, and a multi-part job escalates to a crew.
2. Crews coordinate in the open: a shared board with @mentions, direct messages, append-only notes, a task graph and versioned artifacts. Nothing is edited in place.
3. Two crew modes. Orchestrated: a lead plans and assigns specialists, each on its own model. Swarm: equal peers huddle, merge a plan and claim tasks.
4. Done means checked. An independent reviewer runs real tests, rules and a rubric; agents cannot mark their own work verified. An advisor watches the steps and steers when it sees a concrete problem.
5. Nothing is hidden. Every message, tool call, file and decision is an event in an append-only SQLite log that refuses UPDATE and DELETE. The UI, replay, audit view and exports all read it.

Code

• Works in your project folder and reads AGENTS.md, CLAUDE.md and .myrmidon.md at kickoff.
• File, grep, glob and find tools; ast_grep and ast_edit for structural search and rewrite; lsp for definitions, references and diagnostics; debug with any DAP adapter (debugpy, js-debug, lldb, gdb); eval code cells in JavaScript and Python whose state lasts the round.
• Checkpoints and rewind before a round's first write, diffs per round, and a Git view to stage and commit (it never pushes).
• A git worktree per coding worker, so parallel agents never share a working tree.
• Dev servers agents start and you watch live; an integrated terminal with several shells.
• A github tool for issues, pull requests, diffs, checks and Actions runs; writes always ask you first.
• security_scan for leaked secrets and vulnerable dependencies; autoresearch keeps a change only if a measured metric improves.
• /goal keeps going until a command, the checks or a judge says the goal holds.

Browser and computer

• A real Chrome over CDP: snapshots, click, type, tabs, uploads, downloads, console, network, and browser_extract(schema) to turn a page into JSON.
• Login handoff: the agent asks, you sign in through the live view, it carries on. Agents never type passwords.
• Take over any time; saved browser flows replay as tools; your own tabbed browser beside the chat.
• Computer use on macOS through Cua Driver: one approved app at a time, consequential steps asked first, a glow round the screen and each agent's cursor while it works. Esc stops it.

Crews

• Orchestrated and swarm modes, persistent workers across rounds, and specialists you keep for later chats.
• Mid-round escalation, task rejection with reasons, check-ins and ask_user pauses.
• A live task board, crew map, replay and run comparison with diffs.
• Review fitted to the work: tests for code, citations for research, a rubric for writing.
• Scripted crews in YAML for repeatable runs, with acceptance verifiers and budgets (see below).

Models

• Anthropic, OpenAI, Codex, Gemini, OpenRouter, Ollama, xAI and any OpenAI-compatible endpoint, through oh-my-pi.
• Sign in with the subscriptions you already have: Claude, ChatGPT, Gemini, GitHub Copilot and more. Plan limits show how much of each window is left, as a battery on the model chip.
• A different model per agent, fallback models when one fails, and compaction that respects each model's real context window.
• generate_image and tts for pictures and speech as chat artifacts.

Channels, voice and devices

• 30 channels: Telegram, WhatsApp (linked device or Cloud API), Signal, iMessage, Matrix, Slack, Discord, Mattermost, Microsoft Teams, Google Chat, LINE, WeChat, WeCom, Feishu/Lark, DingTalk, QQ, email, SMS, ntfy, IRC, Twitch, X, Nostr, SimpleX, Zalo, Synology Chat, Nextcloud Talk, Tlon and a generic webhook. They continue the same chats as the app.
• Approved people only. A new sender gets a code and nothing else until you approve them; members always run sandboxed and ask the owner before outside steps.
• Voice and phone calls. Press Call, or ring your Twilio number: a fast call model talks while the crew works. Speech runs locally (Phonon-2, Kitten TTS) or on Deepgram, ElevenLabs, Cartesia, OpenAI, Google, Azure, AWS and more, or the call runs on OpenAI Realtime or Gemini Live.
• Run it on a server and pair your devices over Tailscale or SSH. See docs/remote.md.

Extend it

• MCP servers over stdio, HTTP or SSE, with OAuth and a circuit breaker for flaky ones.
• Plugins in Claude Code's format, from Claude Code marketplaces, git or npm, reviewed before anything runs. Myrmidon plugins can add tools, prompts, chat cards, tabs and Settings pages. Ask the lead for a feature and it builds one as a plugin.
• Skills in the Agent Skills format, from your folders, ~/.claude/skills, projects or a registry. Myrmidon learns new skills from finished rounds and retires the ones nobody uses.
• A skill scanner checks every skill before agents get it: prompt injection, data exfiltration, credential access, obfuscated code, pipe-to-shell installs, login persistence and hidden Unicode. A skill with a critical finding is held until you allow it.
• Hooks in Claude Code's format, stream rules that stop a reply mid-stream when it breaks a rule, and self-made tools kept in a library.
• Memory across chats: a cheap model suggests what to remember, you decide what is kept.

Safe by default

• Commands run in macOS's sandbox: agents read the project and toolchains, write only the project and their work files, and cannot see the rest of your home, other chats or your keys.
• Secrets are redacted from logs and reach model providers as placeholders.
• Every tool can be Allow, Ask first or Off; projects start on ask; each run stops at $5 unless you raise it.
• An audit view of every file, URL and command each agent touched. Want it unrestricted? Turn on full access for a project; approvals still apply.

The app

• A desktop app with native menus, notifications and a Dock badge, or any browser.
• ⌘K command menu, search across every chat, chat groups and forks, a file tree of your project.
• Export a chat as Markdown or a standalone HTML page, share it live with guests, or send an encrypted share file.
• Scheduled rounds, background runs (myr ask --wait) and OpenTelemetry export.

Describe a crew in YAML and run it headless or with the UI:

name: Calculator
mission: ./task.md            # inline text or a .md file
pattern: lead-workers         # or blackboard (swarm)
agents:
  - { name: lead, role: lead, model: anthropic/claude-sonnet-4-5 }
  - { name: coder, role: worker, model: openai/gpt-5, count: 2 }
acceptance:
  - { verifier: checks, rules: [{ artifact: index.html, contains: "<html" }] }
  - { verifier: command, run: "bun test", against: [src/, tests/] }
  - { verifier: llm-judge, model: openai/gpt-5, rubric: ./rubric.md, threshold: 0.8 }
budget: { wall: 15m, costUsd: 5, maxTurns: 40 }
observer: { interval: 30s }

bun run myr run examples/calculator/colony.yaml --ui

Run them with bun run myr …. Data lives in ~/.myrmidon; override with --home DIR or MYRMIDON_HOME.

A Bun + TypeScript monorepo. The HTTP/WebSocket API and the event protocol are the contract, so new clients can follow the app without the runtime changing.