Skip to content
/
Tier A A12 UI passthrough

AgentsMesh

agentsmesh · AgentsMesh/AgentsMesh · ★ 2.1k · last commit 2026-05-26

Primitive shape 7 total
Skills 6 MCP tools 1
00

Summary

AgentsMesh — Summary

AgentsMesh is "The AI Agent Workforce Platform" — a cloud/self-hosted multi-tenant platform for coordinating teams of AI coding agents (AgentPods) via channels, pod bindings, and a task management kanban. Instead of running agents locally one-at-a-time, AgentsMesh lets each human team member spin up remote AgentPods (isolated PTY sandboxes running Claude Code, Codex, Gemini CLI, Aider, etc.), coordinate them through real-time channels and pod binding topology, and track everything via integrated task management — all from a web console or desktop app. The architecture separates control plane (Go API server + gRPC/mTLS to runners) from data plane (Relay cluster for low-latency WebSocket terminal I/O), with a Rust Core providing cross-platform business logic compiled to WASM (web), native dylib via UniFFI (iOS), and NAPI (Electron desktop). The platform supports self-hosting via Docker Compose, multi-git-provider integration (GitHub, GitLab, Gitee), multi-tenant org/team/user hierarchy, SSO, RBAC, and enterprise audit logs.

Differs from seeds: AgentsMesh occupies a different tier from all seeds — it is a SaaS/self-hosted platform with a full web console, desktop app, iOS client, and remote runner infrastructure, not a plugin or CLI tool that augments a single agent session. The closest seed is claude-flow (both run parallel multi-agent workflows), but claude-flow is an npm plugin that runs inside a single Claude Code session, whereas AgentsMesh is a multi-tenant workforce management platform with gRPC runners, relay cluster, and PostgreSQL state. No seed framework has enterprise features (SSO, RBAC, multi-tenant isolation, iOS client, organization-level agent fleet management).

01

Overview

AgentsMesh — Overview

Origin

GitHub org: AgentsMesh. Primary repo: AgentsMesh/AgentsMesh. 2137 stars as of analysis. License: BSL-1.1 (Business Source License) — non-production use free; production requires commercial license until Change Date 2030-02-28, after which GPL-2.0-or-later. Active (last commit 2026-05-26). 10 contributors.

Founded with the thesis that "individual productivity has peaked" and the next frontier is organizational: AI agents from solo tools into a coordinated workforce.

Philosophy

"Give every team member an AI agent squad — assign tasks, track progress, and let them collaborate autonomously."

"Where teams scale beyond headcount."

"Individual productivity has peaked. The next frontier is organizational. AgentsMesh turns AI agents from solo tools into a coordinated workforce."

Core principles:

  • Multi-tenant by design: Organization > Team > User hierarchy with row-level isolation
  • BYOK (Bring Your Own Key): Users provide their own AI API keys — no usage caps, full cost control
  • On-premises option: Runner daemon runs on your infrastructure; code never leaves your environment
  • Real-time collaboration topology: Visualize agent collaboration graph in real-time
  • Cross-platform: Web, Desktop (Electron), iOS (SwiftUI+TCA), all sharing the same Rust Core business logic

Business Model

Hosted SaaS at agentsmesh.ai (primary) + self-hosted Docker option. BSL-1.1 license restricts production use without a commercial license.

02

Architecture

AgentsMesh — Architecture

Components

Component Technology Role
Backend Go (Gin + GORM) API server — auth, org/team/user, pod lifecycle, task mgmt, billing, PKI for runner certs. REST for clients, gRPC + mTLS to Runners. PostgreSQL + Redis.
Relay Go Terminal relay cluster — WebSocket pub/sub. Browser/Desktop/iOS ↔ Relay ↔ Runner. Backend never touches PTY bytes.
Runner Go daemon Self-hosted daemon. gRPC bidi stream to Backend. Spawns isolated PTY pods running AI agents.
Rust Core Rust (10 crates) Cross-platform business logic SSOT. Compiles to WASM (web/desktop), native dylib via UniFFI (iOS). Owns auth, blockstore, channels, tickets, mesh, autopilot.
Web Next.js (App Router + TS + Tailwind) Loads agentsmesh-wasm at boot; UI state mirrors Rust selectors via _tick triggers.
Web-Admin Next.js Admin console at /admin. Internal-only, gated on is_system_admin.
Desktop Electron + electron-vite Renderer reuses clients/web source; main-process node-bridge proxies IPC to Rust Core (native NAPI).
iOS SwiftUI + TCA Consumes Rust Core via UniFFI-generated Swift bindings.

Project Layout

AgentsMesh/
├── backend/          # Go API server
├── clients/
│   ├── web/          # Next.js frontend
│   ├── web-admin/    # Admin console
│   ├── desktop/      # Electron desktop app
│   └── core/         # Rust SSOT (10 crates)
├── runner/           # Self-hosted runner daemon (Go)
├── relay/            # Terminal relay server (Go)
├── proto/            # Protocol Buffers definitions
├── deploy/
│   ├── dev/          # Docker Compose dev environment
│   └── selfhost/     # Self-hosted deployment guide
└── docs/             # Architecture docs + RFCs

Install Methods

Hosted (primary): Sign up at agentsmesh.ai, connect Git provider, install runner:

curl -fsSL https://agentsmesh.ai/install.sh | sh
agentsmesh-runner login
agentsmesh-runner run

Self-hosted (Docker Compose):

git clone https://github.com/AgentsMesh/AgentsMesh.git
cd AgentsMesh/deploy/dev && ./dev.sh

Required Runtime

  • Go 1.24+ (for building)
  • Node.js 20+ + pnpm (for web clients)
  • Docker (for stateful infra: PostgreSQL, Redis, MinIO, Traefik, Jaeger, Gitea, OTel)
  • Rust (for Rust Core, compiled to WASM and native)
  • AI agents: npm install -g @anthropic-ai/claude-code @openai/codex @google/gemini-cli

Build System

Bazel (bazelisk) for reproducible builds. bazel run //deploy/dev:up starts the full stack. The Go services and Next.js apps run on the host via ibazel; Docker only hosts stateful infra.

Network Architecture

  • gRPC + mTLS: Backend ↔ Runner (bidirectional streaming)
  • WebSocket: Relay ↔ Browser/Desktop/iOS (terminal I/O)
  • REST + JWT: Web clients ↔ Backend
  • Dynamically allocated ports per worktree (dev)

Key Config

  • deploy/dev/.env — dev environment ports
  • runner/ — runner daemon config
  • PostgreSQL for persistent state
  • Redis for pub/sub
  • MinIO (S3-compatible) for storage
03

Components

AgentsMesh — Components

Platform Features

Feature Description
AgentPod Remote AI workstation: web terminal, git worktree isolation, real-time streaming. Multiple concurrent pods per user.
Multi-Agent Collaboration Coordinate agents through channels and pod bindings. Real-time collaboration topology visualization.
Task Management Kanban board with ticket-pod binding, progress tracking, MR/PR integration.
Self-Hosted Runners Deploy runners on your own infrastructure. Code stays on your infra.
Multi-Git Provider GitLab, GitHub, Gitee integration.
Multi-Tenant Organization > Team > User hierarchy with row-level isolation.
Enterprise SSO, RBAC, audit logs, air-gapped deployment support.

Claude Code Skills (6, in .claude/skills/)

Skill Purpose
am-delegate Delegate tasks to other agents via MCP delegate_task tool
e2e End-to-end testing guidance
gh-merge GitHub merge procedures
gl-gh-sync GitLab to GitHub sync
merge General merge procedures
worktree Git worktree usage

Note: Each skill is a directory with a SKILL.md file, not a flat markdown file.

Supported AI Agents

Claude Code, Codex CLI, Gemini CLI, Aider, OpenCode, and any custom terminal-based agent.

MCP Integration

.mcp.json in the main repo points to chrome-devtools-mcp@latest (development tooling). The AgentsMesh platform itself exposes MCP tools for agents to interact with the platform (e.g., delegate_task per am-delegate skill). Full MCP server tool count: unknown (platform-level MCP, not publicly enumerated).

ADR Directory

.claude/adr/ — Architecture Decision Records visible to Claude Code when working on the platform itself.

Plans Directory

.claude/plans/ — Development plans for Claude Code.

.claude/settings.local.json

Local Claude Code settings file.

05

Prompts

AgentsMesh — Prompts

Verbatim Excerpt 1: am-delegate Skill

# AM Delegate Skill

This skill allows delegating tasks to other agents in the AgentsMesh platform.

Use the MCP tool `delegate_task` to delegate work to another agent.

Prompting technique: Ultra-minimal tool-use injection. The skill exists to teach a Claude Code agent inside a pod that it can delegate to peer agents via an MCP tool. This is the fundamental coordination primitive — one agent's prompt contains instructions to use the delegate_task MCP tool, which routes work to another pod.

Verbatim Excerpt 2: CLAUDE.md Agent Instructions (project-level)

From the CLAUDE.md of the AgentsMesh repository itself (instructions for agents working on the platform codebase):

## Project Overview
AgentsMesh is The AI Agent Workforce Platform — where teams scale beyond headcount.

## Components
Server-side (Go):
- Backend (backend/): API server (Gin + GORM). REST for clients, gRPC + mTLS to Runner...
- Relay (relay/): WebSocket relay for the terminal data plane...
- Runner (runner/): Self-hosted daemon. Connects to Backend via gRPC bidi stream...

Client-side:
- Rust Core (clients/core/): Business-logic SSOT. 10 crates compiled to WASM (Web/Desktop)...
- Web (clients/web/): Next.js (App Router + TS + Tailwind). Loads agentsmesh-wasm at boot...

Prompting technique: Structured module map as agent context injection — a comprehensive "know the codebase" primer loaded into the agent's context at session start. This is the classic CLAUDE.md pattern but at enterprise scale, covering 8 major components with precise file paths and roles.

Notes on Prompt Visibility

The AgentsMesh platform spawns agents inside isolated PTY pods — the per-feature system prompts, agent configurations, and channel communication protocols are server-side and not visible in the public repository. The public repo shows only the development-environment prompts used by Claude Code when contributors work on the platform itself. The actual per-pod agent prompts delivered by the platform to spawned Claude Code / Codex / Gemini instances are proprietary.

09

Uniqueness

AgentsMesh — Uniqueness and Positioning

Differs from Seeds

AgentsMesh is architecturally distinct from all 11 seed frameworks. The seeds are all "single AI session augmentation" tools — plugins, skill packs, CLI wrappers, or methodology documents that improve what one agent session can do. AgentsMesh is a multi-tenant platform with a backend server, relay cluster, runner daemons, PostgreSQL/Redis persistence, and clients for web, desktop, and iOS.

The closest seed is claude-flow (both coordinate parallel agents), but the comparison breaks down quickly: claude-flow is an npm plugin that runs inside a Claude Code session, adding hive-mind consensus via MCP tools. AgentsMesh is an external platform that manages agent processes (PTY pods) on your infrastructure, communicates over gRPC+mTLS, and stores all state in PostgreSQL. Claude-flow runs your agents; AgentsMesh hosts them.

The Rust Core business logic SSOT compiled to WASM/NAPI/UniFFI for cross-platform consistency is architecturally novel — no seed framework does multi-platform client architecture.

Distinctive Features

  1. Org/team/user multi-tenancy with row-level isolation — no seed has this
  2. Real-time collaboration topology visualization — visual graph of which agents are talking to which
  3. Channel-based agent coordination — agents message each other through persistent channels rather than through a shared prompt
  4. iOS client (SwiftUI+TCA) — no seed has a native mobile client
  5. BSL-1.1 license — commercial, not pure open source
  6. gRPC+mTLS runner protocol — enterprise-grade security for the control plane

Positioning

AgentsMesh targets enterprises and larger teams (5–50 engineers) who want to manage AI agent fleets across their organization, not individual developers augmenting a single coding session. The "workforce platform" framing is deliberate: it's positioned against hiring more engineers, not against other Claude Code plugins.

Observable Failure Modes

  1. Platform dependency: All coordination goes through AgentsMesh servers — if the platform is down, agents can't coordinate.
  2. BSL lock-in risk: The license allows free non-production use, but production use requires a commercial license — a different adoption dynamic from Apache/MIT.
  3. Complexity floor: The full stack (Go backend + Relay + Runner + PostgreSQL + Redis + MinIO) is too heavy for individual developers.
  4. Agent prompt opacity: The system prompts injected into each AgentPod are not publicly visible — operators rely on the platform doing the right thing.
  5. Rust Core coupling: The SSOT pattern (modify state in Rust, not in Zustand/TCA) makes contributions harder for developers who don't know Rust.
04

Workflow

AgentsMesh — Workflow

Human-Centric Agent Management Workflow

  1. Create AgentPod — Operator creates a pod from web console, assigns an AI agent (Claude Code, Codex, etc.) and a Git repo.
  2. Assign Task — Create a ticket in the Kanban board, bind it to a pod.
  3. Agent Executes — Pod runs the AI agent in an isolated PTY sandbox with its own git worktree.
  4. Real-time Monitoring — Watch terminal I/O stream, agent collaboration topology, and progress in the web console.
  5. Collaboration — Agents communicate via channels and pod bindings; operators see the topology graph.
  6. Review — When agent completes work, review the MR/PR in the integrated task management.
  7. Merge — Approve and merge via multi-Git provider integration.

Approval Gates

Gate Type
MR/PR review Human review (via integrated Git provider)
RBAC permission checks Automated (row-level org/team/user isolation)
Unknown additional gates (enterprise features not publicly documented)

State Artifacts

  • PostgreSQL: tasks, channels, tickets, pod state, org/team/user, billing
  • Redis: pub/sub for real-time events
  • MinIO (S3): file storage
  • Git repos: via multi-Git provider integration
  • Audit logs: enterprise tier

Spec Format

No explicit spec format. Task management is ticket/kanban based. No markdown spec files required.

Git Automation

  • Each AgentPod works in an isolated git worktree (one per pod)
  • Agents commit their work within the worktree
  • MR/PR creation is integrated with GitHub/GitLab/Gitee
  • No automatic merge without human review (MR/PR gate)
06

Memory Context

AgentsMesh — Memory and Context

Platform-Level State

  • PostgreSQL: Persistent state for org/team/user hierarchy, AgentPods, tasks/tickets, channels, pod bindings, billing, PKI.
  • Redis: Real-time pub/sub for WebSocket events (terminal I/O relay, pod status updates).
  • MinIO (S3): File/artifact storage.
  • Rust Core: In-memory authoritative cache for the UI layer; synced from PostgreSQL via selectors.

Agent-Level Context

Each AgentPod gets:

  • An isolated PTY sandbox with its own git worktree
  • The agent's configured context (Claude Code CLAUDE.md, etc.)
  • AgentsMesh MCP tools injected (at minimum delegate_task from the am-delegate skill)
  • Channel visibility (the pod can communicate with other pods via AgentsMesh channels)

Cross-Agent Memory

  • Channels: Persistent messaging between pods — agents read/write to channels to coordinate.
  • Pod Bindings: Structural links between pods that define collaboration topology.
  • Shared tasks: Ticket kanban visible to all agents in a project.

Cross-Session Persistence

  • Full persistence in PostgreSQL across sessions — AgentPods, tasks, channel history all persist.
  • Individual AI agent sessions (Claude Code, etc.) may have their own context limits per the underlying tool.

Compaction Handling

Not applicable — AgentsMesh is an external orchestration platform, not a Claude Code plugin. Context compaction is handled by each underlying agent tool independently.

07

Orchestration

AgentsMesh — Orchestration

Pattern

Hierarchical / workforce management. The platform manages a fleet of AgentPods, each running an AI agent in an isolated PTY sandbox. Coordination happens through channels (message-passing) and pod bindings (structural coupling), visualized as a real-time collaboration topology graph.

Organization
└── Team
    ├── AgentPod-1 (Claude Code, worktree A, task: auth)
    ├── AgentPod-2 (Codex, worktree B, task: tests)
    ├── AgentPod-3 (Gemini CLI, worktree C, task: docs)
    └── Channel (agent-to-agent communication)

Isolation Mechanism

Git worktrees — each pod gets its own isolated worktree, so agents work on separate branches without conflicts.

Multi-Model Routing

Yes — each AgentPod independently configures which AI agent/model it runs. No central model routing policy is enforced; operators assign specific agents (Claude Code, Codex, Gemini CLI) to pods. BYOK.

Consensus Mechanism

None in the formal sense. Coordination is message-based (channels) rather than consensus protocols. Merge decisions require human review via MR/PR.

Concurrent Agents

Multiple concurrent pods per organization, up to plan limits. Exact maximum concurrent agents depends on subscription tier (the site shows errors like "Concurrent pod limit exceeded. Please upgrade your plan.").

Execution Mode

Continuous + event-driven. Pods are persistent workstations (unlike ephemeral one-shot agents). The runner daemon maintains persistent connections.

Cross-Tool Portability

Medium — works with Claude Code, Codex, Gemini CLI, Aider, OpenCode, and "any custom terminal-based agent." However, the platform's channel/pod-binding coordination layer is proprietary to AgentsMesh; agents don't generically know about it unless injected with the am-delegate skill.

Audit Log

Enterprise tier: audit logs exist (mentioned in enterprise features). Format and replay capability not publicly documented. The web console shows activity logs per pod/task.

Prompt Chaining

Limited — agents can use delegate_task (MCP tool) to pass work to other pods. Whether one agent's output is automatically injected into another agent's context depends on how channels are configured. More akin to message-passing than automatic prompt chaining.

08

Ui Cli Surface

AgentsMesh — UI and CLI Surface

CLI Binary: agentsmesh-runner

Detail Value
Purpose Self-hosted runner daemon
Install curl -fsSL https://agentsmesh.ai/install.sh | sh
Type Own runtime — manages PTY pod spawning, gRPC bidi stream to Backend
Key subcommands login, login --headless, login --server <url>, run, service install, service start

Web Console

  • Primary interface for operators
  • Tech: Next.js (App Router) + TypeScript + Tailwind CSS
  • Hosted at agentsmesh.ai or localhost:10007 (self-hosted dev)
  • Features: AgentPod management, web terminal, real-time topology visualization, task kanban, channel messaging, MR/PR integration, metrics

Desktop App

  • Electron + electron-vite
  • Renderer reuses clients/web source
  • Main-process proxies IPC to Rust Core (native NAPI)
  • Supports deep-linking to IDEs (Cursor, etc.)

iOS App

  • SwiftUI + TCA
  • Consumes Rust Core via UniFFI-generated Swift bindings
  • Same DTOs and services as web/desktop

Admin Console

  • Next.js app at /admin
  • Internal-only, gated on is_system_admin
  • User/org/runner management, audit logs

Observability

  • Jaeger (OpenTelemetry distributed tracing) — included in Docker dev stack
  • OTel gRPC/HTTP collector endpoints
  • Prometheus-compatible metrics (not confirmed, but standard for Go/Gin services)
  • Activity logs per pod/task in web console

Development Dashboard URLs (self-hosted)

Service URL
Web Console http://localhost:10007
Admin Console http://localhost:10011
API http://localhost:10000/api
Relay ws://localhost:10000/relay
Jaeger UI http://localhost:10014
Adminer (DB) http://localhost:10006

Related frameworks

same archetype · same primary tool · same memory type

Goose (Block/AAIF) ★ 46k
A12 UI passthrough

General-purpose AI agent (not just code) with security-first tool inspection, recipe-based shareable configurations, and 15+ LLM…

Vibe Kanban ★ 27k
A12 UI passthrough

Eliminate the overhead of planning, switching between agent terminals, and reviewing diffs by providing a single web dashboard…

1Code ★ 5.5k
A12 UI passthrough

Cursor-like desktop experience for Claude Code and Codex with cloud background agents, event-driven automations, and a full…

Crystal (stravu) ★ 3.1k
A12 UI passthrough

Manage multiple parallel AI coding sessions in isolated git worktrees from a single desktop GUI.

Maestro (RunMaestro) ★ 3.0k
A12 UI passthrough

Orchestrate unlimited parallel AI agent sessions with a keyboard-first desktop app including Group Chat coordination and Auto Run…

Open Cowork ★ 1.4k
A12 UI passthrough

Makes Claude Code accessible to knowledge workers on Windows/macOS with one-click install, VM sandbox, document skills, and IM…