A commons, public goods project of NimbleCo.

Multiplayer admin and orchestrator platform for Hermes. Deploy, manage, and monitor multiple Hermes Agent instances from one dashboard — with built-in multi-tenant security, model cascades, and platform connections.

First of its kind, a point and click GUI for not just managing Hermes runtimes, but also who can do what and where. Solves the multi-tenant Hermes problem. View the godhead of complexity without derealizing. Share compute.

AI agents are most useful when they're always on — running on a server, reachable from your phone, remembering context across conversations. But running multiple agents across multiple platforms for multiple users? That's where it gets hard.

Hermes Swarm Map is the control plane. One UI to deploy, configure, and manage a fleet of Hermes agents — each with its own personality, memory, platform connections, and budget. Everything a single agent can do, but multiplied and multiplayer.

The indie hacker runs 3 agents: a customer support bot on Telegram, a research assistant on Signal, and a coding helper via API. Each has its own model cascade (Claude for complex tasks, Gemini Flash for quick ones), its own budget cap, and its own personality. HSM manages all three from one dashboard.

The small team gives each team member their own AI assistant on Mattermost. Memory is scoped per-channel — what the engineering channel discusses stays there. The team lead manages API keys, monitors costs, and approves new group connections from HSM.

The AI researcher runs 8 specialized agents across Signal and Telegram for different research domains. HSM handles group approval policies, model fallback chains, and cost tracking across the fleet. New agents deploy in minutes via the wizard.

🧙 Setup Wizard — Deploy a new agent in 5 clicks. Opinionated defaults for compression, memory, security, and voice transcription so it works out of the box.

🔀 Model Cascade — Ordered fallback chains across providers. Start with Claude, fall back to Gemini, fall back to local Ollama. Per-agent.

🔐 Multi-Tenant Security — Per-context memory isolation, group approval policies, admin-only commands, encrypted API keys. Each conversation thread is a walled garden.

📊 Fleet Dashboard — See all your agents at a glance. Health, costs, session counts, model usage. Stop, restart, or rebuild any container from the UI.

🔌 Platform Connections — Connect agents to Signal, Telegram, Mattermost, or expose them via API. Manage surfaces from the UI.

💰 Budget Enforcement — Set monthly spend limits per API key. Agents self-throttle when budget is exceeded.

git clone https://github.com/NimbleCoAI/hermes-swarm-map.git
cd hermes-swarm-map
pnpm install
pnpm seed         # first run: writes settings + tier config
pnpm dev          # http://localhost:3000

On first launch, the setup wizard detects your Hermes compose directories automatically. Point it at your agent directory and go.

New here? Read the Getting Started guide for a full walkthrough.

• Node.js 18+
• Docker running locally (used for container management)
• Hermes Agent instances — see NousResearch/hermes-agent

• Discovery — auto-detect Hermes agent containers and compose files
• Per-agent configuration — edit env vars, SOUL.md personas, surface connections
• Model cascade — ordered fallback chains across providers (Anthropic, OpenAI, Bedrock, etc.)
• Surface management — connect agents to Telegram, Signal, Mattermost
• Restart / rebuild / purge — container lifecycle via UI or API
• Policy enforcement — group access control, DM approval gating, admin resolution
• Agent creation wizard — scaffold and deploy new agents from the UI
• API key management — AES-256-GCM encrypted at rest
• Audit log — track who changed what and when

Build once, run in production mode:

pnpm build
npx next start --port 3000 --hostname 0.0.0.0

Access from any machine on the network at http://<hostname>:3000. Run behind nginx or Tailscale for HTTPS or external access.

Set ALLOWED_DEV_ORIGINS in .env for dev mode on remote machines (see Configuration).

• Next.js 16 (App Router) + TypeScript
• Tailwind CSS v4 + shadcn/ui + Lucide Icons
• Docker CLI (via shell) for container management
• Vitest for testing
• AES-256-GCM key encryption at rest
• File-based agent config at ~/.hermes-swarm-map/

HSM assumes a reasonably trusted team — all users with access to the dashboard can manage all agents, keys, and configuration. There is no per-user role separation or access scoping within a deployment.

What's protected:

• API keys are encrypted at rest (AES-256-GCM) with a machine-local key
• Audit log tracks who changed what
• Per-agent memory scoping isolates conversation contexts
• Group approval policies gate which platforms agents can join

What's not scoped:

• Dashboard access is all-or-nothing — anyone who can reach the UI can manage the fleet
• Skills, tools, and agent configurations are shared across all operators
• The underlying Hermes agent harnesses remain vulnerable to prompt injection from malicious external content (messages, ingested documents), the same as any LLM-based system

Any AI agent (Claude Code, Hermes, etc.) can orchestrate your fleet via the REST API — no GUI needed.

# Examples
curl http://localhost:3000/api/harnesses
curl -X POST http://localhost:3000/api/harnesses/h_myagent/restart \
  -H "Content-Type: application/json" -d '{"mode":"quick"}'
curl http://localhost:3000/api/harnesses/h_myagent/logs?lines=50

Copy .env.example to .env and set:

Settings are stored at ~/.hermes-swarm-map/settings.json. API keys are encrypted at rest with a machine-local key at ~/.hermes-swarm-map/.key.

• Getting Started — deploy your first agent in 5 minutes
• Migrating Existing Agents — upgrade path for existing Hermes users
• Platform Setup — Signal, Telegram, Mattermost, Google Workspace guides
• Image vs HSM Boundary — what belongs in the Docker image vs HSM scaffolding
• Roadmap — what's shipped and what's next
• Contributing — development setup and PR process
• Architecture — service layer, patterns, and agentic development guide

AGPL v3. You can use, modify, and deploy this software freely. If you modify it and expose it over a network (e.g., as a hosted service), you must make your modified source code available under the same license. Self-hosting for your own agents requires no source disclosure.