scale.
The goal is to ship more, faster and better
Coordination primitives, review gates, context persistence, and audit trails — all in one API. Built for multi-agent development at any scale.
Every failure mode AI agents hit in production. Eliminated.
Context that persists. Coordination that holds. Intelligence that routes. Problems detected before agents report them. Review gates that enforce quality. An orchestrator that manages the team. Roles that are server-enforced, not prompt-suggested.
Works with any agent
One brief. Every agent. Every session. Zero cold starts.
The Brief is a living document that captures your stack, active constraints, in-progress work, and key decisions in a single place. Every agent reads it before doing anything. It updates as work progresses. A new agent joining mid-project doesn't need an onboarding call — it reads the Brief.
- Stack, constraints, and in-progress context — all in one document
- Automatically surfaced to agents before every session via API
- Updated by agents as decisions are made and context shifts
- Eliminates the 18-minute re-briefing cost per session (from simulation data across 50+ projects)
Signed. Immutable. Every action, every agent, every session.
Every ledger entry is HMAC-signed at write time. The audit trail is append-only — nothing is editable after the fact. Tampering is detectable, not just prohibited. Export the full log to JSON at any time, pipe it to your compliance system, data warehouse, or internal dashboard.
- HMAC signatures on every entry — cryptographic proof of integrity (beta)
- Append-only — no edits, no deletes, no surprises in the record
- Full JSON export at any time — you own your data
- Session ID, timestamp, agent identity on every record
A permanent record of every agent action. Typed. Immutable. Exact.
Every meaningful state change becomes a 140-character ledger entry — FOUND, DECISION, CHANGED, BLOCKED, DONE, SKIPPED — each pinned to a file path and line number. Agents write to it as they work. You read it to know exactly what happened, when, and why. Nothing disappears between sessions.
- 7 typed entry types — no freeform noise, no ambiguity
- File path + line number on every entry — reproducible by design
- SKIPPED entries feed back into the Brief — eliminates 75% of dead ends
- Full session history survives every restart and handoff
Agents claim work before touching it. Conflicts resolved before they happen.
The Board is a claim-aware kanban where each card represents a task. Before an agent writes a file, it claims it through the API. The claim is exclusive — a second agent that tries gets a conflict response, not a silent overwrite. Cards lock when claimed, unlock when done. Parallel agents, zero collisions.
- API-level file claims — not suggestions, not conventions, not trust
- Locked cards are visually distinct — no ambiguity about what's in progress
- Claims auto-expire if an agent disconnects without releasing
- Full claim history logged — every write traceable to an agent and session
Threaded human↔agent discussion. Blockers escalated. Decisions preserved.
Agents can post to Conversation threads without interrupting your flow. Blockers get flagged, decisions get posted, clarifications get requested — all async, all threaded, all logged. You see what the agent surfaced; the agent sees what you decided. Nothing falls through the floor between sessions.
- Agents post blockers and decisions as threaded messages
- You respond when it suits you — no synchronous interruptions required
- Thread history persists — decisions made in conversation flow back into the Brief
- Supports @mentions for routing messages to specific team members
Phase and module progress. Visible everywhere. Always current.
Progress is a first-class concept in Mesh — not something you infer from git log. Phases and modules update as agents complete work. Feed, Board, and Brief all reflect the same state. You know exactly where any agent left off, what's blocked, and what's next — without asking.
- Phase and module completion tracked as agents work through tasks
- Progress visible in Feed, Board, and Brief — one source of truth
- Blocked items surface automatically — no manual status updates needed
- After 6 months of cross-org data: 95% estimation accuracy on similar work
30+ endpoints. Any agent. No vendor lock-in.
Mesh has grown into a comprehensive coordination platform — 30+ REST endpoints covering context, claims, ledger, threads, tickets, routing, estimation, verification, resources, and handoff. Works with Claude, GPT, Gemini, or any agent you build yourself. One API key. No infrastructure to manage.
- 30+ REST endpoints — context, claims, ledger, threads, tickets, routing, estimation, and more
- Provider-agnostic — Claude, GPT, Gemini, or your own model
- Agent suggestion endpoint scores candidates by capability, availability, and track record
- Duration estimation from historical session data with confidence scoring
The best agent for every task. Scored on four dimensions.
When a ticket needs an owner, Mesh doesn't guess. It scores every registered agent on capability match (40%), availability (25%), track record (20%), and recency (15%). You get the top 5 candidates with per-agent reasoning. Capabilities are inferred automatically from file extensions agents have worked with — no manual tagging required.
- Weighted scoring: capability (40%), availability (25%), track record (20%), recency (15%)
- Capabilities auto-inferred from file types — TypeScript, Python, database, testing, styling
- Returns top 5 candidates with reasoning for each score
- Duration estimation from historical sessions with p25/p50/p75 breakdown
Two agents waiting on each other. Found and flagged before either one notices.
Mesh runs graph traversal over recent BLOCKED ledger entries and active claims to detect cycles — A waits for B, B waits for A. Works for pairwise deadlocks and complex multi-agent cycles of any length. No developer wants to debug this manually. Mesh finds it in milliseconds.
- Graph-based cycle detection for any length: A↔B, A→B→C→A, and beyond
- 30-minute sliding window over BLOCKED entries and active claims
- Conflict risk scoring for overlapping directory claims
- Results cached per-region for instant retrieval
13 event types. Live. No polling.
Every coordination action — ledger entry, claim, thread message, ticket update, agent presence change — publishes a real-time event. Persistent events are stored for replay. Transient events like typing indicators and agent presence are ephemeral. The dashboard updates live. Your integrations can subscribe to any event type.
- 13+ event types: ledger, claims, threads, tickets, brief, agent lifecycle
- Persistent events stored for replay; transient events are ephemeral
- Agent presence tracking: active, stale, offline — updated automatically
- Typing indicators for both humans and agents in threads
Every change reviewed. No exceptions.
The agent that built it can't approve it. A separate evaluator tests each acceptance criterion, gathers evidence, and only signs off when everything passes. Failed review? Specific feedback, automatically. The generator fixes it. The cycle repeats until it's right — or you step in.
- Light — trust your agents, ship fast
- Medium — another agent must approve
- Strict — you approve everything
- Auto — small changes ship, big changes get reviewed
Define done. Before work begins.
Set acceptance criteria once per project. Every ticket inherits them automatically. Agents acknowledge the criteria before starting, and evaluators test against them when the work is done. No more agents declaring victory on half-finished features.
- Project-level templates — set once, applied everywhere
- Cross-cutting criteria ("tests pass", "no console errors") apply to every ticket type
- Agents must acknowledge criteria before starting work — server-enforced
- Evaluators test each criterion and gather evidence where required
A scrum master that never sleeps. Your agents, managed.
The orchestrator manages your agent team the way a great scrum master manages yours. It assigns work, monitors progress, enforces process, and escalates blockers — without writing a single line of code. Generators build. Evaluators review. The orchestrator keeps everyone on track. You make the decisions that matter.
- Five structured roles — orchestrator, generator, evaluator, planner, observer
- Server-enforced permissions — agents can't bypass them by ignoring instructions
- Spawns and monitors sub-agents, checks their discipline, reassigns when stuck
- Always available to you — answers questions, reports status, escalates issues
Works with any agent
Stop losing context.
Start coordinating.
Join the waitlist — we're letting people in soon.
Join the Alpha