by AgentsMesh
The AI Agent Workforce Platform. Run a hundred AI coding agents across your own machines — schedule, isolate, and steer them all from one console.
# Add to your Claude Code skills
git clone https://github.com/AgentsMesh/AgentsMeshLast scanned: 4/26/2026
{
"issues": [],
"status": "PASSED",
"scannedAt": "2026-04-26T06:09:11.332Z",
"semgrepRan": false,
"npmAuditRan": true,
"pipAuditRan": true
}AgentsMesh is an open-source ai agents skill for AI coding assistants such as Claude Code, Codex CLI, and ChatGPT, built by AgentsMesh. The AI Agent Workforce Platform. Run a hundred AI coding agents across your own machines — schedule, isolate, and steer them all from one console. It has 2,275 GitHub stars.
Yes. AgentsMesh passed SkillsLLM's automated security scan — a dependency vulnerability audit plus prompt-injection heuristics — with no high-severity issues. You can read the full report in the Security Report section on this page.
Clone the repository with "git clone https://github.com/AgentsMesh/AgentsMesh" and add it to your Claude Code skills directory (see the Installation section above).
AgentsMesh is primarily written in Go. It is open-source under AgentsMesh on GitHub, so you can review or fork the full source.
Yes. SkillsLLM lists many other AI Agents skills you can browse and compare side by side. Open the AI Agents category from the badge at the top of this page, or use the Related Skills and comparison links further down to weigh AgentsMesh against similar tools.
No comments yet. Be the first to share your thoughts!
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:
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.
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 wall you hit | What AgentsMesh gives you |
|---|---|
| 100 agents won't run on one machine | Runner fleet — install self-hosted runners across any number of machines. Each advertises its capacity (max_concurrent_pods), and agents are scheduled onto the runner you pick or an available one from the pool. Your code never leaves your infrastructure. |
| Every agent needs a clean, isolated environment | Workspace isolation — each agent runs in its own pod with a dedicated Git worktree sandbox (sandboxes/{pod}/workspace/), private credentials, and its own branch. Concurrent agents never step on each other. |
| You can't watch a hundred terminals | One console, every screen — Web, Desktop (Electron), and iOS (SwiftUI) clients, all driven by the same Rust core. Paginated pod sidebar, multi-pane workspace, and real-time terminal streaming let one person hold many agents in view. |
| Long-running agents stall and need babysitting | Autopilot — a control agent watches a pod and sends the next instruction the moment it goes idle, with iteration caps, decision history, and human takeover/handback. Self-healing, unattended runs. |
| Agents working alone don't compound | Mesh & Channels — bind pods together, let them talk over channels with @mentions, and watch the collaboration topology update in real time. |
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.
@mentions.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)
| Component | Role |
|---|---|
| Backend | API server (Gin + GORM) — auth, org/team/user, pod lifecycle, tickets, billing, and the PKI that issues runner certs |
| Relay | WebSocket relay for the terminal data plane — low-latency pub/sub between runners and clients |
| Runner | Self-hosted daemon — connects to the backend (gRPC+mTLS), spawns isolated PTY pods that run the actual agents |
Client-side
| Component | Role |
|---|---|
| Rust Core | Business-logic SSOT — 10 crates compiled to WASM (web/desktop) and a native dylib via UniFFI (iOS). One cache, one set of services, every client. |
| Web | Next.js console — terminal, Kanban, real-time mesh topology |
| Desktop | Electron app — reuses the web UI, talks to a native Rust core over NAPI |
| iOS | SwiftUI + TCA — the same Rust core via UniFFI bindings |
| Web-Admin | Internal admin console — user/org/runner management, audit logs |
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.
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.)
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
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.
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:
| Service | URL |
|---|---|
| Web Console | http://localhost:3000 |
| API | http://localhost:80/api |
Test Accounts:
| Role | Password | |
|---|---|---|
| User | dev@agentsmesh.local | devpass123 |
| Admin | admin@agentsmesh.local | adminpass123 |
Ports are dynamically allocated per worktree. Check
deploy/dev/.envfor actual values.
Prerequisites: Go 1.24+, Node.js 20+, pnpm, Docker
# 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
Docker images are published to Docker Hub on every push to main:
agentsmesh/backend:sha-xxxxxxx
agentsmesh/web:sha-xxxxxxx
agentsmesh/web-admin:sha-xxxxxxx
agentsmesh/relay:sha-xxxxxxx
Tagged releases (v*) get semver tags:
agentsmesh/backend:1.0.0
agentsmesh/backend:1.0
See deploy/selfhost/ for the self-hosted deployment guide.
Any terminal-based agent works. The built-ins:
| Agent | Provider | Description |
|---|---|---|
| Claude Code | Anthropic | Autonomous AI coding agent |
| Codex CLI | OpenAI | OpenAI's code generation CLI |
| Gemini CLI | Google Gemini CLI | |
| Aider | Open Source | AI pair programming in the terminal |
| OpenCode | Open Source | Open source AI coding tool |
| Custom | Any | Any terminal-based agent |
| Layer | Technology |
|---|---|
| Backend | Go (Gin + GORM) |
| Client Core | Rust → WASM (web/desktop) + |