musterd

Roadmap

What has shipped, what is next, and what musterd has ruled out on principle. The full build sequence, with per-item references, is in ROADMAP.md.

shipped

  • Driver co-presence — When a human steers an agent inside its session, the roster shows the human present — not offline.
  • The resolve act — A terminal "done" signal for a thread. accept is not finished; resolve closes the loop.
  • Reachability nudge — musterd notify pushes a localhost OS notification so an away human learns an agent needs them.
  • Telemetry — Layer 1 — One OTLP span per Envelope on the validate → persist → route path, plus act and team metrics. Off by default, no phone-home.
  • Harness adapters — Claude Code, Cursor, and Codex each get a rendered role MCP server. Codex writes a project-local .codex/config.toml.
  • Seat stops flapping on health-check probes — Agent single-active displacement is scoped by workspace: a same-seat reconnect (a reload, or Claude Code’s periodic MCP health-check spawn) no longer supersedes the live session — only a genuinely different session does.
  • One-command agent workspaces — musterd agent <name> adds an agent AND gives it its own isolated workspace, binding, and MCP registration — so two actors never fight over one folder’s seat.
  • Verify provisioning, don’t assume — The SessionStart hook checks the musterd server is actually registered before telling an agent it’s auto-joined; if not, it prints the fix instead of a false reassurance.
  • Layered guidance surface — primer, skill, help, hooks — musterd init writes an on-demand skill (seat claiming, handoff-with-branch, recovery) and slash commands alongside the primer, slimming the always-loaded primer to a loop kernel — with drift checks so the generated guidance can’t silently rot as the platform evolves.
  • Committed launch spec — a clone self-wires — A secret-free .musterd/workspace.json rides the repo, so a fresh clone/workspace registers the musterd MCP server with one no-prompt `musterd wire` — no interactive init.
  • Workspace-family MCP entry — a shared slot carries no per-seat state — Claude Code keys local MCP config by repo root, so every seat workspace shares one entry — which used to carry the last provisioner’s credentials. It now carries nothing: identity and secrets resolve from each workspace’s own binding.json.
  • Claim on first use — A folder claim policy and live claim bring a running pending session online — no relaunch, no wire change.
  • Cross-network teams — Two people on two machines can share a team today — run the daemon on a Tailscale/WireGuard overlay and point each member’s MUSTERD_SERVER at its overlay address.
  • Availability axis + urgent breakthrough — A human sets their own availability (available/away/dnd, away_until); an urgent flag with a required reason breaks through an away/dnd hold, and the notify loop tiers delivery by it.
  • Daemon service lifecycle — musterd service runs the daemon as a background service that survives a closed terminal, restarts on crash, and starts at login — without raw launchctl.
  • Agent-side reachability — The agent half of the reachability loop: a directed act waiting for an agent surfaces on every command it runs, so a heads-down agent can’t miss a request_help addressed to it.
  • Service guardrails — musterd service stop/restart refuses when other members hold live sessions, so bouncing a shared daemon doesn’t silently drop a teammate.
  • Hand off & claim a seat without leaving the tool — A teammate issues a ready seat to another agent in one command, the receiver adopts it in one command, and a claim conflict no longer dead-ends — it names the runnable next command.
  • Ambient agent presence — An agent doing bursty one-shot CLI work shows present on the roster instead of offline — liveness from real actions, not just a resident watch socket.
  • Durable seat roster on git — A team’s seat roster lives as committed .musterd/ files; the daemon is a projection of them, so the git history of seats/ is the membership audit log — while live state (presence, tokens) stays daemon-only.
  • Multi-identity vault — A second agent joining a team on the same machine can no longer clobber the first’s cached token — every claimed identity is kept, keyed by (team, member).
  • Traces & evals first-class gate — Every agent-facing feature ships with its traces and an eval, the way it ships with tests — a required ADR section and a format:check guard enforce it. Cheap and compounding, so later features inherit it.
  • Inbox reaches a blocked agent — A teammate’s message reaches an agent parked on an approval prompt — surfaced into the terminal the human is already at — instead of waiting until the human hand-relays it.
  • Wake on message — An idle agent blocks until its next directed act arrives and resumes immediately — instead of polling on a timer or missing the message in the gap.
  • CLI ergonomics — The papercuts a fresh agent hits in its first five minutes — identity, version, inbox filters, one-command replies.
  • v0.3 governance — build plan & spec reconciliation — The phased decomposition of the v0.3 governance rock, the four directional decisions, and the spec-gap resolutions — so the breaking auth change lands as one isolated, reviewed moment.
  • v0.3 P1 — seats data model — The substrate: account_status + capabilities on a seat, roles carrying default capabilities + charter, per-seat narrowing (never widening). Permissive defaults, no enforcement yet.
  • v0.3 P2 — in-band enforcement & audit — The first real governance value, on the existing token auth: gate urgent on can_flag_urgent, admin-only governance routes, viewer-scoped visibility, account-status enforcement, and an append-only audit log.
  • v0.3 P3 — credentials & the claim handshake — The breaking auth rework: team agent key + admin-issued grants + human credentials, the WS claim frame replacing hello, and the no-grant request/approval lane — cut over across every surface at once.
  • Notification tiers — The full reachability set: route an agent’s request for help to a human by salience and availability, not only when they are watching.
  • Coordination lanes (Phase 1) — own the work, never dup a diff — A first-class lane = { work-item × owner × surface } so musterd advises before two agents (or humans) redo the same work — the anti-swarm primitive.
  • Close the dogfood telemetry gaps (instrument-by-default) — Turned the built-but-inert telemetry on and wired the missing surfaces — so the next multi-agent session is measurable live, not reconstructed forensically.
  • Web dashboard — live team console — A browser console for the team: the firehose observer stream, the live roster, and the governance/approval web views — a read-only window onto the same Members.
  • Live isometric office — Replace the /live constellation with a 2D isometric animated co-work office — presence→placement, act→choreography, travel-intensity == notification tier.
  • Plan/Goal model + `musterd next`/`done` — The orientation + handoff spine that kills the copy-paste toil: a declared Plan→Goal skeleton — the backlog noun — with derived status, and one-command next/done.
  • Insight engine — server-side projections — One projection engine in the daemon — Goal status, the board view, flow metrics, waiting-on — computed over Goals × lanes × threads, never stored, exposed as an HTTP API.
  • Reporting altitudes + waiting-on view (CLI + MCP) — `musterd report` at IC/team/exec altitudes and the "N threads waiting on <human>" bottleneck view — the first surfaces of the insight engine, with MCP parity.
  • Coordination-density insight — An insight that flags when a team’s traffic is all broadcast-journal and no directed or threaded exchange — coordination that only looks collaborative.
  • The interrupt line — reach a busy agent mid-loop — A directed steer reaches an agent busy mid-task at its next tool-call boundary — the missing reachability rung for a loop that is neither idle nor blocked, but heads-down on its own work.
  • Steer & challenge acts (+ plan-mutation verbs) — Give steering first-class semantics: a directive `steer` that supersedes prior direction, an epistemic `challenge` that forces revalidation, and a `defer` verb that reorders/defers a Goal on the plan.
  • Plan epochs & dependency-targeted invalidation — Catch stale work even when an interrupt misses: a goal carries a plan epoch, `defer` re-sequences it and bumps it, and only the lanes actually building against the moved plan get a targeted warning.
  • Steering-latency & stale-work-caught metrics — The number the launch demo is built around: measure how fast steering reaches a busy agent, and how much stale work the anti-staleness layer actually catches.
  • Keep the declared record honest — truth check + the steward seat — The roadmap can’t silently lie: its shipped-status is derived from a verifiable anchor and checked against git + ADR statuses, and a standing steward seat hunts the drift a static check can’t see.
  • musterd gives any harness residency (resume the offline) — The offline rung: a seat binding holds the harness session id, so the daemon can resurrect an exited session on a directed act — turning a turn-scoped harness into an always-on one.
  • Telemetry — Layer 2 + SDK — A full CLI/MCP telemetry SDK, then MAST-aware views over the act-typed log that agent-observability tools cannot see.
  • Persistent seat memory — A persistent identity wants persistent memory — the seat carries a continuity note across the session gap, headline-first.
  • Model experimentation — frontier cadence + own models — Treat the model itself as a first-class experimental variable: be early to each frontier model, and own models end-to-end.
  • Model diversity as a team-composition feature — Same-model agents agree in correlated ways, so their consensus is weak evidence. Record the model per occupancy and flag same-family review/approval chains — making model diversity a first-class team property.
  • cookoff — the controlled experiment that proves musterd’s value — The commercial crux: a sellable, defensible number for coordinated-vs-siloed agents on the same task — one reusable instrument (the cookoff scenario) that also answers the model and harness questions by varying a different term.
  • Re-found the human role — human↔agent coordination, reevaluated whole — The dedicated design pass that reevaluated the human’s role in musterd end-to-end — presence, steering, notification, approval, and thread-close — against the humans-as-peers thesis and what the dogfood record actually shows. Complete: it re-sequenced the human-loop backlog into the items below.
  • Dogfood-mode approval — a standing grant for re-seating known agents — Stop the bleeding: re-occupying a seat you already held becomes a notification, not an admin decision. Brand-new member admission stays gated. First policy of the configurable approval surface.
  • The to-human ask stream — tiered asks, timeouts, no-answer policy — One directed-to-human stream, three species (consultative ask / escalation / approval), each carrying a tier that sets a timeout and a no-answer policy. Top tier holds; below-top proceeds with a recorded risk-acceptance. Nothing below top wedges. Harness permission prompts explicitly excluded.
  • Ask surfaces — Slack delivery + a loud /live asks & approvals panel — Deliver the ask stream where the human already lives: a Slack message naming what needs a decision, and a prominent asks/approvals element on /live. The CLI inbox demotes to a power tool.
  • The human presence ladder — steering marks you working — Humans get agent-equivalent presence from signals humans already emit: steering marks you working, an authenticated /live tab marks you online, and a stale status decays to idle. Presence informs the ask-stream escalation-eagerness; absolute time still drives every timeout. This resolved the driver co-presence gap rather than patching it.
  • Human work identity — create & claim lanes from the web UI — Humans create and claim lanes/Goals from the web UI, just like agents — so blockers, human-only work (publish to npm), and self-defined human work are captured, measured, and auditable. No new work-item nouns; the writable board is the missing affordance.
  • Two-stage close — awaiting acceptance + counterpart outcome accept — Split "done" into the worker’s claim (`awaiting_acceptance` after merge) and a counterpart’s outcome acceptance (intent/principles/usable/feel — not a code review). Missing acceptor → self-close recorded unconfirmed, never a wedge. Vocabulary clarified in ADR 192; mechanics from ADR 169.
  • Work items, board & insight layer (web) — The kanban-style board and team analytics rendered in the web dashboard — a thin surface over the insight engine, never a second store.
  • Packaging — npm release + Homebrew + post-install UX — Shipped ADR 156: `pnpm release` (pnpm publish, lockstep @musterd/*), Homebrew npm-wrapper tap, engines Node ≥22, CLI gate + doctor packaged notes. Registry live at 0.3.1 (0.3.0 deprecated — had unreplaced workspace:*).
  • Driver co-presence gap — make steering light up the human — Closed by ADR 155 Increment 1: `musterd agent --driver` provisions the once-dormant MUSTERD_DRIVER link, and a human steering a live agent seat now composes as working + online on the roster — derived from the driver link at read time, no presence row of their own.
  • Install topology — the team home is where the human stands — One machine, one daemon, many teams, many repos — and every seat has a floor: agents stand in per-seat workspaces, the human stands in a per-team home (`~/musterd/<team>`). `musterd human <name>` provisions it in one command, a lost human credential becomes recoverable, and the shared agent key can never occupy a human seat.
  • Roles & stewardship — a role library with an infra-touch guardrail — Create and assign named roles (steward, platform guardian, product manager, UX designer, facilitator/brainstorm, experimenter, researcher, support, database guru…) with charters + capabilities — including "only designated platform agents touch running infrastructure".
  • Authorization provenance (who approved it) — For audit: when a decision, escalation, or merge routes to a human for authorization, record which human authorized it — a first-class, attestable link from an approved action back to the approver.
  • Tool-call telemetry — which tools get used, and what they cost — musterd records coordination acts, never tool calls. Emit a per-tool-call event — tool name, latency, error, caller role, estimated schema weight — so we can see how the MCP surface is actually used and what it costs.
  • musterd’s MCP server, examined — names, descriptions, schemas, results & discovery — Treat musterd’s own MCP server as a designed product surface — both what an agent sends and what it reads back. Audit the 18 tools’ names, descriptions, and schemas for clarity and weight, fix the namespace drift, make every result (empty states included) informative and action-naming for an agent, and give a seat a lean surface it can discover instead of a wall of schema on every call.

near-term

  • The office earns being watched — /live and /broadcast stop misinforming, then delight — A stranger who lands on the stream mid-flow can tell what they are watching, trust what the room shows them, and want to keep looking. Decomposed into increments that can each be accepted — credibility first, beauty last.
  • Codex harness parity — CLI residency and desktop evidence — Codex CLI becomes a native, safe residency backend with the same coordination outcomes as Claude Code; Codex desktop is verified separately and stays manual-resume until a stable supported wake API exists.
  • Coordination-traces dataset & MAST-in-the-wild — The first research artifact: an open, redacted dataset of real human+agent coordination traces on HuggingFace, plus MAST failure detectors over the act-typed log — the data no single-agent vendor can produce.
  • Roles vs toolkits — responsibility without harness lock-in, routing behind its gate — Keep roles as team-owned responsibilities and move harness setup into separate local workspace toolkits; role routing stays deferred behind measured demand.

reserved

  • v0.3 P4 — credentialed remote join — Plug the agent key + grant + human credential into the already-built secured off-loopback bind, so a teammate on another machine joins over wss with a real credential, not a locally-minted token.
  • Eval & experiment engine (batond) — Parked standalone product: team-outcome evals and side-by-side experiments over model × prompt × harness × team topology — on a bought, Langfuse-shaped backend if built. Not required for musterd’s R&D flywheel (ADR 194).
  • Research radar (ingest) — A standing scan/triage of new multi-agent-coordination research, funneled into research-foundation.md — findings that change a decision graduate to an ADR.
  • Schedule & lifecycle enforcement — availability and lifecycle: until are stored today but not enforced. Later: honor windows for routing and auto-expire members.
  • Step-level streaming transport — v0.1 sends whole Envelopes. A v2 transport adds step-level streaming, which beats wait-for-complete for collaborating agents.
  • Team-to-team federation — A Member belongs to one Team today. Teams that address one another, and identities recognized across Teams, come later.
  • Slack surface (iOS deferred) — A Slack surface, so a Member is reachable where its human already lives; a native iOS app is explicitly deferred behind it.
  • Coordination lanes — Phase 2 (observed surface + merge-funnel) — The observed-surface + merge-funnel layer on top of the Phase-1 lane primitive — tighter contention signal, less reliance on declarations.
  • Web steering console — answer consultative asks from /live — Pull the steering the founder does inside each harness (approve/deny/redirect, plan feedback, "what do you think") into musterd, answerable from /live — unifying consultative asks, escalations, and approvals into one addressed-to-human stream. Harness permission prompts stay in the harness, permanently.
  • Multi-human admin model — the two-human dogfood — The admin overlay for teams with more than one human: admins are human-only (≥1 always, creator default), a second human joins as non-admin, and a configurable fallback routes asks to non-admin humans on admin silence. Deliberately last — its open questions can’t be honestly designed with one human.
  • musterd as its own harness & mixed-harness teams — musterd grows a standalone harness/chat of its own — a seat that runs on musterd directly, like Claude Code or Codex, instead of only sitting on top of them — then mixed-harness teams as a first-class shape.
  • Ledger seats — every actor on the roster (services as members) — The roster becomes the complete census of actors on a machine — humans, agents, and now services: peer seats can decline and hold lanes; ledger seats (kind: service) carry identity, roles, attribution, and audit for the unattended actors that act most.
  • Sandboxed runtime — musterd connects agents; it does not run them. A later, optional sandbox could host members with nowhere else to live.
  • Python client SDK — A fast follow after launch. The protocol is language-neutral; the TypeScript client is the reference, not the only one.
  • Shared/remote-team security hardening — The security cluster that follows the v0.3 governance work once teams span machines: recipient-scoped message reads, multi-admin delegation, rotating/per-seat keys, a signed audit log, and abuse limits.
  • Hosted rendezvous relay (Topology C) — A musterd-operated hosted relay members dial out to — the "just works" path for teams that won't run a Tailscale/WireGuard overlay.

out of scope

  • A planner / orchestrator role — One member does the work; the team does the coordination. musterd never forces decomposition.
  • Running your agent — Protocol over framework. We connect agents; we don’t own their execution loop.