Building an AI Software Dev Team with OpenClaw

How I set up 10 specialized AI agents as a full software development team — with Discord, Mission Control, and smart API routing. This is just general overview and plan idea. Source code and Prompts not included.

---

The Idea

I wanted a real AI dev team, not just a single chatbot. Something that mirrors how an actual small dev team works — a PM, an architect, frontend, backend, QA, DevOps, security, code reviewer, doc writer, and a scrum master. Each agent with its own role, personality, and tools.

The stack I landed on:

• OpenClaw — always-on agent runtime (runs Claude Code under the hood)

• Discord — the team's communication hub (dedicated server: Geek)

• Mission Control — Kanban + token analytics dashboard

• Agency-Swarm — Python orchestration for multi-agent pipelines

• Promptfoo — QA evaluations and security red teaming

• Impeccable — design language guidelines for frontend AI output

---

The Team — 10 Geek Agents

All agents share the geek- prefix. No human names — just clean role IDs.

Agent	Role	Model
geek-pm	Product Manager	MiniMax
geek-architect	Tech Lead & Architect	Claude
geek-frontend	Frontend Developer	MiniMax
geek-backend	Backend Developer	MiniMax
geek-qa	QA Engineer	Codex
geek-devops	DevOps Engineer	Codex
geek-reviewer	Code Reviewer & Bug Fixer	Claude
geek-docwriter	Documentation Writer	MiniMax
geek-security	Security Auditor	Claude
geek-scrum	Scrum Master	MiniMax

API Routing Logic

Three API keys, used strategically:

• Claude → fixing issues, code reviews, security audits (high reasoning tasks)

• Codex → test generation, DevOps scripts (code-execution tasks)

• MiniMax → development, documentation, planning (high-volume tasks)

---

Workspace Structure

Each agent lives in its own workspace directory:

~/.openclaw/
├── workspace-geek-pm/
│   ├── AGENT_PROMPT.md      ← role instructions
│   ├── IDENTITY.md          ← name, emoji, vibe
│   ├── SOUL.md              ← personality
│   ├── TEAM_CONTEXT.md      ← injected by switch-team.sh
│   ├── MEMORY.md            ← persistent memory
│   └── memory_steps/        ← SOPs by task type
├── workspace-geek-architect/
│   └── ...
├── workspace-geekteam/      ← shared team workspace
│   ├── scripts/
│   │   ├── switch-team.sh   ← swap web ↔ mobile context
│   │   ├── api-router.sh    ← route task to right API
│   │   └── pipeline.sh      ← run full feature pipeline
│   ├── agency-swarm/        ← Python orchestration layer
│   ├── team-profiles/
│   │   ├── web.yaml         ← Next.js 15 + TS + Tailwind + PG
│   │   └── mobile.yaml      ← React Native + Expo + EAS
│   └── api-routing/
│       └── routing-rules.yaml

---

Multi-Team Support Without Duplicating Agents

One of the design goals: run a web team today, switch to mobile tomorrow — without creating 10 new agents.

The solution is TEAM_CONTEXT.md injection. One script rewrites the context file for all 10 agents at once:

./switch-team.sh web
# → writes web stack context to all 10 agents' TEAM_CONTEXT.md
# → no restart needed, agents pick it up on next message

./switch-team.sh mobile
# → same agents, now thinking React Native + Expo

Team profiles (web.yaml, mobile.yaml) define:

• Tech stack

• Per-agent context overrides

• API routing preferences

• OpenViking namespace for tiered context loading

---

Discord Setup — 3 Bots, 3 Servers

OpenClaw's multi-account Discord support lets each server have its own bot identity:

"discord": {
  "accounts": {
    "default": { "token": "...", ... },   // @KLinked — KLinked HQ
    "blog":    { "token": "...", ... },   // @Blogs   — Blog server
    "devteam": { "token": "...", ... }    // @Geek    — Geek server
  }
}

Bindings route each agent to the right channel:

{ "agentId": "geek-scrum",    "match": { "channel": "discord", "accountId": "devteam", "guildId": "..." } },
{ "agentId": "blog-research", "match": { "channel": "discord", "accountId": "blog", "peer": { "kind": "channel", "id": "..." } } }

The Geek server currently routes all messages to geek-scrum as the default handler in the #general channel. As more channels are added, each agent gets its own dedicated channel.

---

Mission Control Dashboard

builderz-labs/mission-control connects directly to the OpenClaw gateway:

Mission Control (localhost:3000)
    ↕ WebSocket
OpenClaw Gateway (localhost:18789)
    token: [gateway auth token]

What it gives the team:

• Kanban board — track tasks across all 10 agents

• Token analytics — monitor Claude / Codex / MiniMax usage per agent

• Session viewer — see what each agent is working on

• Natural language scheduler — queue tasks across agents

Setup was straightforward:

git clone https://github.com/builderz-labs/mission-control
cd mission-control
pnpm install
# configure .env with OPENCLAW_GATEWAY_* vars
pnpm build && pnpm start

---

Agency-Swarm Pipeline

For complex features, a Python orchestration layer chains agents together:

User request
    → geek-pm (requirements)
    → geek-architect (design)
    → geek-frontend + geek-backend (parallel build)
    → geek-qa (tests)
    → geek-reviewer (review)
    → geek-docwriter (docs)

Each agent in the pipeline uses LiteLLM for model routing, and delegates all file writes to Claude Code via claude --print:

# api routing via LiteLLM
AGENT_MODEL_MAP = {
    "geek-architect": "claude-sonnet-4-6",
    "geek-qa":        "openai/gpt-5.3-codex",
    "geek-pm":        "minimax/minimax-code-01",
    ...
}

---

QA & Security

geek-qa runs Promptfoo evaluations on every PR:

• Component rendering tests

• API response shape validation

• Edge case coverage

geek-security runs OWASP Top 10 red team scenarios:

• SQL injection probes

• Auth bypass attempts

• XSS payload testing

Both agents write results back to Mission Control via the /api/tokens endpoint.

---

What's Next

• [ ] Add per-channel Discord routing as team grows (architecture, backend-work, qa-reports, etc.)

• [ ] Wire Sprint board to Mission Control Kanban

• [ ] Enable OpenViking L1/L2 context tiers as memory builds up

• [ ] Set up Impeccable design language enforcement in geek-frontend's review loop

• [ ] Mobile team profile live run with React Native project

---

Lessons Learned

OpenClaw binding schema is strict. Only channel, accountId, guildId, and peer are valid in match objects. Adding unknown fields (channelName, description) silently blocks all config reloads — check gateway.err.log first when things don't reload.

Multi-Discord via accounts, not channel plugins. Custom channel IDs like discord-blog don't work. The correct approach is discord.accounts.<name> with bindings using accountId.

TEAM_CONTEXT.md injection > agent duplication. 10 agents covering both web and mobile is always better than 20 agents with half sitting idle.

MiniMax for volume, Claude for quality, Codex for code execution. This split keeps costs manageable while routing the right reasoning power to the right tasks.