README.md

Where teams scale beyond headcount.

The AI Agent Workforce Platform.
Run a hundred AI agents across your own machines — and command them all from one console.

Website · Docs · Quick Start · Discord · X · X (founder) · LinkedIn

The problem: one operator, a hundred agents

AI coding agents have made individual engineers wildly productive — but individual productivity has a ceiling. The next 10x isn't a smarter agent; it's running many agents at once, and directing them like a team.

That ambition breaks the moment you try it for real:

• A hundred agents won't fit on one laptop.
• Nobody can babysit a hundred terminals.
• Each agent needs its own clean, isolated workspace — or they corrupt each other's state.
• Long-running agents stall, get stuck, and silently die.
• Agents working in isolation never compound into a team.

What's missing isn't the agent. It's the control layer that turns one operator into the director of an agent workforce — the layer that schedules agents onto machines, isolates them, keeps them alive, lets them collaborate, and puts all of it on one screen.

AgentsMesh is that layer.

From problem to platform

Every part of AgentsMesh exists to answer one question: how does a single person reliably run, watch, and steer a hundred agents? Each capability is the direct answer to a wall you hit when you scale.

The rest is plumbing built so that chain holds up under load: a control-plane / data-plane split — orchestration over gRPC with mTLS, terminal bytes over a stateless Relay cluster — so the backend never bottlenecks on PTY traffic, no matter how many agents are streaming at once.

Core concepts

• AgentPod — one agent's isolated execution environment: a PTY terminal, a Git worktree sandbox, and a real-time output stream.
• Runner — a self-hosted daemon you install on your own machines. It connects to the backend over gRPC+mTLS and spawns pods. Register as many as you need; pods schedule across the fleet.
• Workspace — the per-pod sandbox: an isolated Git worktree plus private credentials, so concurrent agents never collide and every run is recoverable.
• Autopilot — autonomous, self-healing control of a pod by a control agent, with iteration limits, decision history, and human takeover at any point.
• Mesh & Channel — the collaboration fabric: pods bound into a topology, communicating over channels with @mentions.
• Ticket — a unit of work on a Kanban board, bindable to a pod with progress and MR/PR tracking.

Architecture

AgentsMesh separates the control plane from the data plane: orchestration commands travel over gRPC with mTLS, while terminal I/O streams through a stateless Relay cluster. The backend never touches a single PTY byte — which is what lets the fleet scale.

Server-side (Go)

Client-side

Getting Started

The fastest way to use AgentsMesh is the hosted service at agentsmesh.ai — sign up, connect your Git provider, and start running agents in minutes. Bring your own AI API keys (BYOK): no usage caps, full cost control.

1. Install a Runner

The Runner is a lightweight daemon that runs on your machine and executes AI agents locally. Your code stays on your infrastructure. Install one per machine you want in the fleet.

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

See the Runner README for more installation options (deb, rpm, Windows, etc.)

2. Login

agentsmesh-runner login

This opens your browser to authenticate. For headless environments (SSH, remote server):

agentsmesh-runner login --headless

For self-hosted deployments, add --server:

agentsmesh-runner login --server https://your-server.com

3. Run

agentsmesh-runner run

Or install as a system service for always-on operation:

agentsmesh-runner service install
agentsmesh-runner service start

Once the runner is online, create an AgentPod from any console (Web / Desktop / iOS) and start putting agents to work.

Quick Start

Run the whole stack locally with one command.

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

This starts the full stack: PostgreSQL, Redis, MinIO, Backend, Relay, Traefik, and a local Next.js frontend with hot reload.

Access:

Test Accounts:

Ports are dynamically allocated per worktree. Check deploy/dev/.env for actual values.

# 1. Start infrastructure
cd deploy/dev && ./dev.sh

# 2. Backend (auto-starts in Docker with hot reload)
docker compose logs -f backend

# 3. Frontend (local with Turbopack)
cd clients/web && pnpm install && pnpm dev

agentsmesh/backend:sha-xxxxxxx
agentsmesh/web:sha-xxxxxxx
agentsmesh/web-admin:sha-xxxxxxx
agentsmesh/relay:sha-xxxxxxx

agentsmesh/backend:1.0.0
agentsmesh/backend:1.0

Supported Agents

Any terminal-based agent works. The built-ins:

Tech Stack

Project Structure

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

Contributing

We welcome contributions! See CONTRIBUTING.md for guidelines.

• Code of Conduct
• Security Policy

License

Business Source License 1.1 (BSL-1.1)

• Change Date: 2030-02-28
• Change License: GPL-2.0-or-later

The BSL allows you to use, copy, and modify the software for non-production purposes. Production use requires a commercial license until the change date, after which the software becomes available under GPL-2.0-or-later. See LICENSE for the full terms and additional use grant.