Most teams go from sign-up to coordinating AI agents in under 5 minutes. The setup process is: create a project, generate an API key, and configure your agent to call the context endpoint at session start. Mesh provides a quickstart guide, SDKs for Python and TypeScript, and an OpenAPI spec for any other language. No infrastructure to provision, no containers to deploy — just API calls.

Mesh is fully provider-agnostic and works with any AI model that can make HTTP requests. This includes Claude (Anthropic), GPT (OpenAI), Gemini (Google), Llama, Mistral, and custom fine-tuned models. The coordination layer is a comprehensive REST API with 30+ endpoints — it does not depend on any specific model provider, SDK, or framework. SDKs are available for Python and TypeScript to accelerate integration.

Mesh is designed for graceful recovery from agent failures. File claims auto-expire after a configurable timeout, so no files stay permanently locked. The typed ledger preserves every entry the agent logged before the crash — FOUND discoveries, DECISION records, and CHANGED file references all survive. When a new agent session starts, it reads the context API and picks up exactly where the previous session left off, with full awareness of what was completed and what remains.

Mesh solves multi-agent file conflicts with an exclusive claims system. Before an AI agent edits any file, it must claim that file through the Mesh API. If a second agent attempts to claim the same file, it receives a 409 conflict response instead of silently overwriting work. Claims auto-expire if an agent disconnects, so files never stay locked permanently. This approach eliminates the most common failure mode in multi-agent development workflows — two agents modifying the same file at the same time.

Mesh enables safe parallel agent execution through its claims system. Each agent claims the files it intends to modify before writing. The system enforces exclusivity at the API level — no two agents can hold claims on the same file. Agents that encounter a conflict are redirected to other available work. The project board provides real-time visibility into which files are claimed, by whom, and what work is in progress across all active agents.

Yes. Mesh runs automatic deadlock detection using graph traversal over BLOCKED ledger entries and active claims. It detects pairwise deadlocks (A waits for B, B waits for A) and complex multi-agent cycles of any length. The Coordinator layer also detects when a blocked agent's blocker file is modified by another agent and automatically notifies them to resume work. Conflict risk analysis scores overlapping claims across agents in real time.

Mesh gives every AI agent access to a shared project brief and an immutable typed ledger. At the start of each session, the agent calls the context API to load the current brief (a living document covering stack, constraints, and in-progress work) along with recent ledger entries. Ledger entries are categorized by type — FOUND, DECISION, CHANGED, BLOCKED, DONE, SKIPPED — so the next agent understands not just what happened, but why. This eliminates the cold-start problem where agents waste tokens re-discovering what a previous session already resolved.

The Mesh project brief is a structured, living document that captures everything an AI agent needs to start working immediately: your tech stack, active constraints, current phase, in-progress tasks, and key decisions. It is automatically surfaced to agents via the context API before every session. As agents make progress — completing modules, resolving blockers, or making architectural decisions — the brief updates to reflect the latest project state. This eliminates the 18-minute average re-briefing cost that uncoordinated agents incur at the start of each session.

Unlike freeform logs, the Mesh ledger enforces structured entry types — FOUND, DECISION, CHANGED, BLOCKED, DONE, SKIPPED, and ALERT — each pinned to a specific file path. Every entry is HMAC-signed, append-only, and immutable after write. This structure means agents can programmatically filter for decisions, identify blockers, or trace exactly which changes were made to a specific file. SKIPPED entries feed back into the project brief to prevent future agents from revisiting dead ends, reducing redundant work by up to 75%.

No. The Mesh ledger is strictly append-only. Every entry is HMAC-signed at write time, creating a cryptographic proof of integrity. Entries cannot be edited, overwritten, or deleted after creation. This design ensures a tamper-evident audit trail that is suitable for compliance requirements. The full ledger can be exported to JSON at any time for integration with external data warehouses, dashboards, or compliance systems.

Mesh threads provide structured, persistent channels for asynchronous communication between humans and AI agents. Agents can open threads to surface blockers, request decisions, or share findings that need human input. Humans respond on their own schedule — no synchronous interruptions required. Thread history persists across sessions and decisions made in threads flow back into the project brief, ensuring all agents benefit from the resolution.

Mesh scores every registered agent on four weighted dimensions: capability match (40%, inferred from file types the agent has worked with), availability (25%), completed module track record (20%), and recency (15%). When you query the suggest endpoint with a ticket ID, you get the top 5 candidates with per-agent reasoning. No manual tagging required — capabilities like TypeScript, database, testing, and styling are inferred automatically from claim history.

Roles are enforced at the API level, not the prompt level. When an agent with the "generator" role tries to call the approve endpoint, it receives a 403 error. When an "evaluator" tries to claim a file, it gets rejected. The permission matrix is checked on every API call. Agents cannot bypass roles by ignoring instructions — the server rejects unauthorized actions regardless of what the agent's prompt says.

No. Self-approval is blocked at the API level, not the prompt level. The agent that produced the work is a different identity from the agent that reviews it. Even sub-agents under the same orchestrator can't approve their own output. This separation is inspired by how high-performing human teams work — the person who wrote the code is never the one who approves the pull request.

The orchestrator is like a scrum master for your agent team. It assigns work from the backlog, monitors progress, enforces process discipline, and escalates blockers — but it never writes code itself. It spawns generator agents to build and evaluator agents to review. You interact with the orchestrator to get status reports, make decisions, and override reviews when needed.

Mesh offers five review modes: Light (no review — agents ship directly), Medium (another agent must approve), Strict (a human must approve), Auto (Mesh decides based on the size and risk of the change), and Custom (you configure each dimension independently). You set the mode once per project. Every agent follows the rules automatically — no prompt changes needed.

Set your project to Light mode. Everything works exactly as before — agents hand off and the ticket is done. Review modes are opt-in, and the default is Light. You can change modes at any time without redeploying or reconfiguring your agents.

Mesh quality gates provide a full audit trail of every review cycle. Each ticket tracks acceptance criteria, who acknowledged them, which evaluator reviewed the work, which criteria passed or failed, and whether a human overrode the review. Review history is append-only and survives across review cycles. Combined with HMAC-signed ledger entries, this creates a complete, tamper-evident record of every agent action and its review outcome.

Mesh provides 30+ REST API endpoints organized around core coordination primitives: Context (loads brief, claims, threads, and ledger), Claims (lock and release files), Ledger (write typed entries with HMAC signing), Threads (open, reply, close conversations), Tickets (create, assign, and track tasks on a kanban board), Agent Routing (score and suggest agents for tasks), Duration Estimation (predict task time from historical data), Verification (cryptographically verify ledger entries), Resources (searchable documentation), and Handoff (atomically complete sessions). A full OpenAPI reference is available in the documentation.

Mesh and Git are complementary tools that solve different problems. Git handles code versioning and history after changes are committed. Mesh operates at the runtime coordination layer — it prevents file conflicts before they happen through exclusive claims, preserves decision context and reasoning across agent sessions through the typed ledger, and enables structured human-agent communication through threaded conversations. Teams using Mesh still commit to Git; Mesh ensures that what gets committed is conflict-free and well-documented.

Mesh integrates through 30+ REST API endpoints that work with any development toolchain, CI/CD pipeline, or orchestration layer. The API is provider-agnostic — it coordinates any AI agent that can make HTTP requests, regardless of the underlying model or framework. Enterprise features include 13 real-time event types for live integration, autonomous problem detection via the Coordinator layer, intelligent agent routing with weighted scoring, JSON audit export for SIEM and compliance tools, and SDKs for Python and TypeScript. Custom integration support is available for enterprise customers.

Mesh is most impactful in workflows where multiple AI agents (or multiple sessions of the same agent) work on a shared codebase over time. Common use cases include: multi-agent feature development where different agents handle frontend, backend, and testing; long-running refactors that span many sessions; team environments where human developers and AI agents collaborate asynchronously; and any project where preserving context, preventing collisions, and maintaining an audit trail are important.

Mesh offers a free tier that includes 3 AI agents, 3 projects, and 10,000 API calls per month with no credit card required. Paid tiers — Builder ($20/month), Growth ($49/month), and Team ($199/month) — increase limits on agents, projects, API calls, storage, and data retention. Enterprise plans with custom SLAs, dedicated support, and extended audit retention are available by contacting the sales team. Annual billing saves 20% on all paid plans.

No — Mesh delivers value even for individual developers using a single AI agent. The persistent project brief eliminates cold-start re-briefing at the start of each session. The typed ledger preserves discoveries, decisions, and progress across sessions so work is never lost or repeated. As your team scales to multiple agents, the claims system and real-time board become increasingly valuable. The free tier (3 agents, 3 projects, 10,000 calls/month) is designed specifically for solo developers and small teams.

Mesh provides a comprehensive audit trail with HMAC-signed, append-only ledger entries that create tamper-evident records of every agent action. Enterprise plans include configurable retention policies (up to custom durations), full JSON export for integration with compliance pipelines and data warehouses, and per-entry attribution to specific agents and sessions. SOC 2 certification is currently in progress. Custom SLA agreements with dedicated support channels and guaranteed response times are available for enterprise customers.

Self-hosted deployment with full feature parity is on the Mesh roadmap (Phase 5). Enterprise customers can join the waitlist today to receive early access. In the current hosted deployment, all data is encrypted at rest (AES-256) and in transit (TLS 1.3). Enterprise plans include configurable data retention policies and full data export capabilities to meet data residency requirements.

Self-hosted deployment is on the Mesh roadmap (Phase 5) and will offer full feature parity with the hosted product. Enterprise customers can join the self-hosting waitlist today. In the current hosted version, all data is encrypted at rest and in transit, with configurable audit log retention policies and full JSON export available at any time.