Deploy autonomous AI teams that grow your business while you sleep.

Agent Teams gives you a workforce of AI specialists that collaborate, execute, and deliver.

Self-hosted. Open source. Industry-agnostic.

Quickstart · Docs · Deploy · License

#What did my AI team do overnight?

✓ Researched 14 competitor landing pages and wrote a positioning memo
✓ Published 3 social media posts and scheduled 5 more
✓ Found and contacted 22 inbound leads with personalized outreach
✓ Built a lead scoring dashboard from CRM data
✓ Analyzed last week's campaign performance and proposed optimizations
✓ Asked me two questions

I woke up to a summary.

Agent Teams runs 24/7 on your machine or VPS. When you wake up, your agents have been working all night. No babysitting. No context loss. No runaway costs.

#Why this exists

Hermes gives you one AI employee — a powerful agent with a terminal, browser, and file access.

Agent Teams gives you an entire AI company.

Hermes is the worker. Agent Teams is the manager, the scheduler, the budget controller, and the operations console.

OpenAI

Anthropic

Gemini

Ollama

Qwen

DeepSeek

Kimi

OpenRouter

Z.ai

40+ providers via Hermes. Or route everything through one OpenAI-compatible endpoint.

#Problems Agent Teams solves

#How Agent Teams compares

#Example teams you can build

Marketing Team

Strategist    → Researches trends, identifies opportunities, defines positioning
Copywriter    → Writes social posts, emails, blog drafts, ad copy
Analyst       → Tracks campaign performance, segments audiences, reports ROAS
Publisher     → Schedules posts, manages distribution, monitors engagement

Sales Team

Prospector    → Generates leads, researches accounts, scores opportunities
Outreach      → Personalizes emails, follows up, books meetings
Deal Manager  → Tracks pipeline, manages proposals, coordinates approvals
Analyst       → Monitors quotas, forecasts, identifies churn risks

Support Team

Triage        → Categorizes tickets, routes to specialists, sets priority
Resolver      → Troubleshoots issues, applies fixes, escalates when stuck
Documenter    → Writes knowledge base articles from resolved tickets
Analyst       → Tracks SLAs, identifies trends, suggests process improvements

Operations Team

Orchestrator  → Monitors workflows, alerts on failures, restarts stalled jobs
Reporter      → Generates daily summaries, surfaces anomalies, delivers briefs
Compliance    → Checks policy adherence, flags risks, prepares audit logs

Build any of these in minutes with the Architect — the built-in AI team builder that interviews you, designs the team, and builds it on approval.

#Features

#What Agent Teams is not

#Quickstart

Have an AI coding agent? Paste one of these prompts into Claude Code, Codex, opencode, or Hermes itself and it'll install and set up the whole teams for you — clone, dependencies, provider, and first run.

Install and run Agent Teams on this machine for me.

Agent Teams (https://github.com/CyberTron957/agent-teams) is a
self-hosted multi-agent server with a real-time dashboard.

1. Check Python 3.11+ (or Docker). If missing, tell me before installing system packages.
2. If ./agent-teams doesn't exist, clone the repo there. Run the installer
   non-interactively: `bash install.sh --no-run`. It auto-skips the interactive
   wizard when there's no TTY, so it won't hang. (Add `--no-browser` only if the
   Chromium download fails — everything else still works.)
3. Check whether a provider is already configured — run `.venv/bin/agent-teams doctor`.
   If it already shows a model (e.g. an existing `~/.hermes` setup), ADOPT IT —
   don't ask me for keys, the teams reuses it automatically. Skip to step 5.
4. Only if NO provider is configured, ask me for:
      - provider (e.g. openai, anthropic, or "custom" for an OpenAI-compatible / proxy endpoint)
      - model name, API key, and base URL (base URL only for custom/proxy, e.g. http://localhost:4000/v1)
   Then set it with the supported NON-interactive command (do NOT edit Python internals):
     .venv/bin/agent-teams set-model --provider <p> --model <m> [--base-url <url>] --api-key <key>
   Then tell me that `set-model` only sets the model — for web-search, vision,
   browser providers, memory, and reasoning-effort customization I can run the
    full wizard myself anytime: `.venv/bin/agent-teams setup`. Offer to run it.
5. Verify: `.venv/bin/agent-teams doctor` (a "backend not reachable" warning is
   fine if my model server isn't running yet).
6. Scaffold a team and start the server detached:
     .venv/bin/agent-teams init
      .venv/bin/agent-teams up --detach   # daemonizes and returns; don't background it yourself
   It prints the URL once /health is up. Confirm with `.venv/bin/agent-teams status`.
   (Use `up --detach`, NOT `nohup … &` — backgrounding it from your shell means it
   dies when your session/process group ends.)
7. Tell me how to manage it and build my first team:
      - open the dashboard at http://127.0.0.1:8000 and use the Architect
      - check status:  .venv/bin/agent-teams status
      - stop it:       .venv/bin/agent-teams down
      - customize more: .venv/bin/agent-teams setup

Keep my API key local — don't commit it or send it anywhere.

Deploy Agent Teams on this VPS, exposed safely over HTTPS.

Agent Teams (https://github.com/CyberTron957/agent-teams) is a
self-hosted multi-agent server. Its agents can run terminal commands as the
server user, so containment and auth matter. Please:

1. Read docs/deploy-vps.md in the repo and follow its hardened path. Prefer the
   Docker route so the agents' terminal access stays contained.
2. Clone the repo and bring it up with Docker Compose (restart: unless-stopped).
3. Generate a strong TEAMS_API_KEY and set it — it must guard every endpoint and
   the WebSocket. Show it to me once and store it somewhere I can find it.
4. Configure the LLM provider via `hermes setup` against the shared config —
   PAUSE and ask me for the provider + API key.
5. Put it behind a TLS reverse proxy (Caddy or nginx) for my domain — ask me for
   the domain/subdomain — with automatic HTTPS.
6. Lock down the firewall: only 80/443 and SSH open; do NOT expose the raw app
   port.
7. Verify: GET /health returns ok, and the dashboard loads over HTTPS and prompts
   for the API key.
8. Report back the URL, where the API key is stored, and how to watch logs
   (docker logs / journald).

Ask me before anything destructive. Never print my API key or provider key into a
file that could be committed.

Or do it yourself — macOS & Linux, one line.

bash <(curl -fsSL https://raw.githubusercontent.com/CyberTron957/agent-teams/main/install.sh)

# Docker
git clone https://github.com/CyberTron957/agent-teams agent-teams && cd agent-teams
docker compose run --rm teams agent-teams setup  
docker compose up --build

# From a clone 
git clone https://github.com/CyberTron957/agent-teams agent-teams && cd agent-teams
bash install.sh

Requirements: Python 3.11+, Chromium (for browser tools: npx playwright install chromium)

#After install

agent-teams setup       # configure provider + model
agent-teams doctor       # preflight check
agent-teams init         # scaffold a starter team
agent-teams up --detach  # start the server
open http://127.0.0.1:8000  # open the dashboard

#CLI Reference

#Slash commands

Type / in any dashboard composer — the agent message box, the Architect chat, or an inbox reply — to get an autocompleting command palette. Commands run against the orchestration layer and never become an LLM turn, so checking usage or interrupting a stuck agent costs nothing.

Autocomplete completes command names, subcommands (/goal <tab>), and live argument values — /model <tab> offers the models your provider actually serves. ↑/↓ to move, Tab/Enter to accept, Esc to dismiss.

Command names match Hermes' own CLI, but where the two systems mean different things, Agent Teams' meaning wins — you're driving a team, not a chat session:

Some Hermes commands are intentionally not available: /undo and /retry need a transcript store Agent Teams doesn't have, /title is meaningless for long-lived named agents, and /compress would report success without actually shrinking an agent's context. A /-prefixed line that isn't a real command is rejected with a suggestion rather than forwarded to the model, so a typo can't quietly burn a turn. Pasted paths (/Users/you/brief.md) are treated as ordinary text.

Only humans can run commands. Agents message each other through the same endpoint, so an agent sending /pause to a teammate is delivered as plain text — it can't drive another agent's control plane.

#FAQ

How is this different from running multiple Hermes agents in separate terminals? Agent Teams gives them a shared project directory, peer-to-peer messaging (they can delegate and report to each other), supervisor agents that watch for stalls, a human inbox for questions, budget enforcement, and one dashboard to see it all. Separate terminals give you none of that.

Can I use any LLM provider? Yes. Hermes supports 40+ providers natively (OpenAI, Anthropic, OpenRouter, Google, Groq, Together, DeepSeek, and more). Or route everything through one OpenAI-compatible endpoint (LiteLLM, custom proxy, local Ollama).

What happens when an agent's context gets too long? Hermes' built-in ContextCompressor auto-compacts sessions at 75% of the context window. Turn summaries and the recent tail are preserved in a child session; the raw history is pruned. Agent Teams also ages stale tool results and sweep payloads at replay.

Can I stop an agent mid-turn? Yes. Pause freezes the queue and preserves pending tasks. Stop interrupts the in-flight turn via Hermes' interrupt() API, drains pending tasks, and waits for the worker thread to unwind.

Does this work on a headless VPS? Yes. The dashboard is served over HTTP, and the embedded browser takeover streams the headless Chrome via CDP screencast — no display needed. The Docker route also contains the agents' terminal access.

Can the embedded browser feel like a real browser instead of a screencast? Yes — that's the neko viewer. With Docker available, each team's browser panel becomes a 60fps WebRTC stream of a real, visible Chromium running in a container (ghcr.io/m1k1o/neko/chromium): native tabs, omnibox, downloads, audio, sub-300ms input. Your agents keep driving the same browser and profile over CDP — the container just exposes --remote-debugging-port alongside the stream. Cookies persist in data/teams/<team>/.browser-profile exactly as before. It's on by default when Docker answers; set TEAMS_VIEWER=local to force the built-in CDP screencast canvas (also used automatically as fallback), or tune with NEKO_IMAGE, NEKO_SCREEN, NEKO_ADVERTISE_HOST. Each team's container costs ~1GB RAM while running; the panel's Stop button tears it down until server restart.

How do costs work? Every turn logs token counts (input, output, cache read). These are priced against a built-in provider pricing table and summed per-agent and per-team. Set a daily USD (or token) cap per team — agents auto-pause when the limit is hit and resume at 00:00 UTC.

#Deploy on a VPS

See Deploy on a VPS for the hardened deployment guide — TLS reverse proxy, firewall lockdown, Docker containment, and TEAMS_API_KEY setup.

#Development

git clone https://github.com/CyberTron957/agent-teams.git
cd agent-teams
python -m venv .venv && source .venv/bin/activate
pip install -e .
agent-teams setup    # configure provider + model
agent-teams init     # scaffold a team
agent-teams up       # start the server

#Community

• Discord — chat and community
• GitHub Issues — bugs and feature requests
• GitHub — source code and releases

#License

MIT © 2026 Pradhyun

_{Open source under MIT. Built for people who want AI agents that ship, not just chat.}