A team of agents, working from one board.
Self-hosted multi-agent orchestration. Built on Claude — adaptable to any model provider, local or cloud. Each agent lives in its own persistent container — Docker on a home server, Kubernetes in production, or Fly Machines globally — with its own personality, memory, and credentials. Drag work onto a kanban. Watch them collaborate.
Tasks flow through statuses you configure. The dispatcher auto-runs cards in the right column. Cards land in Done. Each lane behaves like you'd expect — except the workers are AI specialists running in their own containers, not people.
↳ try dragging a card between columns
Every status column has three boolean flags. Combine them to model any review process — sequential approvals, hand-back loops, escalations.
Drop a card in. If the agent's container is up and under its concurrency cap, dispatch fires within seconds. Use for Todo / In Progress lanes.
Agent uses mm-status review "<question>" to land cards here. Your next comment flips the card back to autoRun and resumes the agent.
Run button disabled. But: a human comment on a terminal card auto-reopens it to the first autoRun status. Done isn't forever.
Talk to the orchestrator. It routes sub-questions to the right specialist agent automatically. You see one conversation; under the hood, multiple Claude processes are collaborating on your behalf.
When Atlas spots a question that fits another agent's expertise, it uses mm-call to delegate — and the response comes back in the same thread, tagged with the specialist's name and accent colour.
--resumeAgents are persistent containers with baked-in identity. Different system prompts, different skills, different MCP servers, different env vars, different bind mounts. The orchestrator routes work to whoever fits best.
Routes work to specialists. Provisions new agents. Inspects task state. Manages the team. Higher concurrency cap (5) because it's always busy delegating.
Searches semantic indexes (Qdrant + bge-m3), live SharePoint via Graph API, and read-only archive mounts. Returns source links + excerpts, never invents.
Builds branded documents, decks, landing copy. Knows the brand palette. Generates Word + PDF + Excel side-by-side, polishes typography before delivery.
Writes code, debugs systems, reviews diffs. Uses Bash/Edit/Read deeply. Talks to MCP servers for testing infra. The team's hands-on engineer.
Creates product mockups, marketing visuals, social-media graphics, diagrams. Generates SVGs and illustrations on demand; knows the brand palette and typographic system inside out.
Qualifies inbound leads, drafts proposals from boilerplate, formats quote covers, manages handover docs to delivery teams. Calls Vera when historical context is needed.
You design the agents you wish you'd hired — then you actually use them every day.
Multi-agent setups earn their keep on work that's repeatable, document-heavy, or cuts across people who don't normally sit together. A few patterns that map cleanly to the architecture — the personas mentioned are just example fits from a typical crew.
"Find me everything we have on X" across years of SharePoint, network shares, and project folders. A librarian agent runs semantic vector search, cross-references with live source-of-truth APIs, and returns cited excerpts with paths back to the original — no fabrication, every claim links to a real file.
Generate proposals, audit reports, quote covers, or weekly summaries that respect a brand palette + typography system. Outputs land as Word + PDF + Excel side-by-side, ready to send. Re-runs with different content stay visually consistent.
Walk a codebase, propose diffs, write tests, debug stack traces, draft pull requests. A developer agent uses Bash / Read / Edit / Grep deeply, can spin up scratch services via MCP, and returns reviewable patches rather than vibe-coded blobs.
"List every non-conformance raised this year by client, with root cause and corrective action." The orchestrator delegates the lookup to the librarian, hands findings to the document agent to format as an audit-ready report, all in one task thread.
Ingest emails / tickets / form submissions, classify by urgency + topic, summarize the thread, and draft a first-pass reply. A triage agent escalates anything novel; routine items go through with a human "send" click.
Monday-morning rollups: open work, blockers, deliveries since last week. Cron fires the recurring task; the orchestrator pulls data, the document agent formats it, the file lands in your shared volume before you've opened your laptop.
Drop a folder of PDFs, get a normalised spreadsheet. Line items, prices, dates, parties pulled into structured rows you can filter and pivot. Re-run when the source changes; the schema stays stable.
"What's our X workflow? Who owns Y? Where's the spec for Z?" The librarian surfaces the relevant docs, the orchestrator stitches them into a coherent tour. New starters self-serve their first week of how-do-I questions.
Pull boilerplate from past wins, drop in the new scope, generate a draft response with consistent voice + compliant structure. Reviewable in hours, not days. The developer agent can also draft technical sections.
Persistent context across sessions is what makes an agent feel like a teammate rather than a chatbot. MultiManager gives each agent three memory layers, each tuned to a different time-scale and access pattern.
A single markdown blob prepended to every dispatch. Use for facts that should never be forgotten — user preferences, working agreements, stable defaults.
Vector memory in a Qdrant collection. Agents write notes, search them later by meaning, share team-scoped memories across the crew.
Each task gets its own session UUID. The dispatcher resumes via --resume <id>; multi-turn conversations carry full context across hours, days, or container recreates.
Long-running async systems break. MultiManager bakes recovery into the architecture so an app crash, container restart, or mid-stream failure becomes a non-event — no manual intervention needed.
Applies pending migrations. Marks any stuck-running executions as failed. Resumes tasks that were mid-flight when the app went down. Starts the cron scheduler + watchdog.
Scans running executions. Tracks output growth. If an execution's stdout hasn't grown in 5 minutes, marks it failed and clears the task lock. Catches silent dispatcher crashes.
New comment on a paused task? Flip the card back to autoRun. New comment on Done? Reopen it. The agent picks up your latest message without manual restart.
Designed to live anywhere containers run — a single Docker host at home, a Kubernetes cluster in production, or a fleet of Fly Machines distributed globally. Postgres is the source of truth. The app spawns per-agent workloads on demand. Each agent has its own persistent storage for workspace, memory, and Claude's session files.
Next.js 16 server. Kanban + chat UI, REST API, dispatcher, cron scheduler, watchdog. Provisions agents through a pluggable runtime abstraction.
Postgres 17. Tasks, comments, agents, statuses, attachments, cron jobs, usage records. Migrations apply on every boot.
One persistent workload per agent — Docker container, K8s pod, or Fly Machine. Same image, same volumes, same behaviour on every runtime.
A single AgentRuntime interface fronts every container lifecycle, file, and exec operation. Pick a backend via one env var; the dispatcher, file UI, memory layer, and peer-delegation pipeline don't change.
The default. One persistent container per agent on a single host. Named volumes for workspace + memory. docker exec for streaming + one-shot ops. Ideal for self-hosting on a home server, NUC, or single VPS.
One StatefulSet (replicas=1) per agent with per-replica PVCs. Headless Service for stable DNS. Native streaming exec via the apiserver. Drop in next to your existing workloads with standard RBAC.
One Fly Machine (Firecracker microVM) per agent, addressed over 6PN private networking. A bundled WebSocket daemon handles streaming stdio. Per-agent regional placement for latency-sensitive specialists.
MultiManager was initially built on Claude for its OAuth flow, stable tool-use protocol, and session-resume support. But the kanban, dispatcher, orchestration, memory tiers, and self-healing recovery — none of it depends on which model is on the other end. Swap providers per-agent without touching the rest.
Default deployment path. Bills against your subscription quota (Claude) or per-token API rates (others). Each agent can target a different provider — orchestrator on a smart model, specialists on cheaper ones.
Run the entire team on-prem. No per-token costs, no data leaves your network. Larger 70B+ models handle the orchestrator; smaller models keep high-volume specialists snappy.
Cloud Claude for routing intelligence; local Ollama for semantic-heavy librarians; cheaper OpenAI for high-volume drafting agents. Cost-optimise per agent role; sensitive data stays local.
Beyond standard Claude tools (Bash, Read, Edit, Write, Grep, Glob), MultiManager ships mm-* shell scripts that let agents discover teammates, delegate work, manage their memory, post progress comments, and move tasks between statuses.
Attachments upload to a shared volume mounted in every agent container. Inline previewers render most office formats directly in the browser so you can verify what the agent saw without downloading.
Most of the work isn't the agents — it's the surrounding scaffolding that keeps them alive, fed, and recoverable. MultiManager handles all of that.
Boot recovery, stale-execution watchdog, comment-driven retrigger. Crashes and restarts are non-events.
SSE pipes each agent's stdout into your browser. Watch tool calls, file reads, and decisions in real time.
Per-agent memory file, semantic memory in Qdrant, Claude session JSONLs — all survive every container recreate.
Drop-in skill markdown files. MCP server connections. Plugins. Each agent gets its own toolbelt.
Drag a docx/xlsx/pdf into chat. The agent reads it. Inline previews for spreadsheets, Word docs, PDFs, images.
Schedule recurring tasks to fire on cron expressions. Soft-archive (and restore) anything you've finished with.
Custom env vars, extra Docker volume mounts, fine-grained access. One agent can have SMB read; another can't.
Uses your Claude OAuth token. Bills against your subscription quota, not metered API tokens.
Agents call each other with mm-call. The orchestrator routes work to specialists in the same chat thread.
XLSX, DOCX, PDF, CSV, images, HTML, audio, video — all render inline without leaving the app.
× on a chat or kanban card archives instead of deletes. Restore from Settings → Archive whenever.
Per-agent embedding daemon runs nomic-embed-text as ONNX — ~3× faster than cross-host Ollama for semantic loops.