Multi Agent Orchestrator

Design, build, and manage multi-agent teams that turn a solo operator into a 1000-person organization. Covers team role design (CEO/PM/Engineer/Analyst/Write...

Security Scan

Instruction-only multi-agent orchestration guide that is internally consistent with its stated purpose and does not request extra credentials or install artifacts, but review workspace usage and platform-specific commands before running in production.

Purpose & Capability

The name and description (design/build/manage multi-agent teams) match the SKILL.md and reference files. The instructions reference platform CLIs and features (e.g., OpenClaw sessions_send, cron, shared filesystem) but the registry metadata declares no required binaries — this is plausible for an instruction-only, platform-agnostic guide, but users should note that running the examples in practice will require platform tooling (OpenClaw/cron/etc.).

Instruction Scope

The SKILL.md stays on-topic (team design, communication patterns, task flows). It instructs agents to read/write shared workspace files, create AGENTS.md, set up cron heartbeats, and use messaging APIs. Those actions are expected for orchestration, but they do involve reading/writing files in a shared workspace; if that workspace contains secrets or system files, agents could access them — the skill does not instruct reading unrelated system files or exfiltrating data to external endpoints.

Install Mechanism

No install spec and no code files are provided, so nothing will be written to disk by the skill itself. This is the lowest-risk form for skills and is coherent for a documentation/instructions package.

Credentials

The skill declares no required environment variables, credentials, or config paths. That aligns with being an instruction-only orchestration guide. There are no unexplained requests for secrets or unrelated service credentials.

Persistence & Privilege

always is false and disable-model-invocation is false (normal). The skill does not request persistent or elevated privileges; it does instruct setting up recurring jobs (cron) and shared directories at the user's discretion, which is normal for orchestration workflows.

Assessment

This skill is an instruction-only playbook for running multi-agent teams and appears coherent with that purpose. Before using it: (1) Ensure the shared workspace you point agents at does not contain secrets or system files — agents will read/write files there. (2) If you plan to run the examples, install and secure any platform tooling referenced (OpenClaw CLI, cron) — the skill doesn't declare those binaries but uses them. (3) Be careful when giving agents network or cloud access (the templates assume data collection and external actions); grant the minimal privileges needed. (4) Because the skill is autonomous-invocable by default, review any automation triggers you enable so agents cannot perform unexpected actions without human oversight. If you want a lower-risk test, run the templates in an isolated workspace or staging environment first.

Build production-grade agent teams. Battle-tested with 13 concurrent agents running real operations—financial analysis, content production, code engineering, and executive decision-making.

Core Philosophy

One human, many agents. Each agent has a narrow, well-defined role. Communication flows through structured channels. The human sets direction; agents handle execution.

Three laws of agent teams:

1. Specialization over generality — Each agent does ONE thing well
2. Structured communication — No ad-hoc messaging; use defined protocols
3. Human-in-the-loop for decisions — Agents execute, humans decide

Workflow

Step 1: Define Your Team Composition

Read references/team-roles.md to select roles from the template library.

Start minimal (3 agents), scale to what you need:

Team Size	Composition	Use Case
Solo+1	Human + 1 Assistant	Personal productivity boost
Core (3)	CEO + PM + Engineer	Small project delivery
Full (5+)	+ Analyst + Writer + Monitor	Business operations
Enterprise (8+)	+ Specialist roles per domain	Multi-domain scaling

Step 2: Design Communication Architecture

Read references/communication-patterns.md for protocol details.

Choose your communication stack:

Pattern	Latency	Best For
Shared directory	Minutes	Async handoffs, document sharing
Message passing (sessions_send)	Seconds	Real-time coordination
Heartbeat scheduling	Periodic	Monitoring, health checks
Event queue	Async	Complex multi-step workflows

Step 3: Set Up Task Management

Read references/task-management.md for tracking systems and report formats.

Implement the three-layer task system:

1. Strategic (CEO layer) — Goals and OKRs
2. Tactical (PM layer) — Sprint planning and allocation
3. Operational (Engineer layer) — Ticket execution and delivery

Step 4: Launch and Iterate

# Minimum viable team setup
1. Create AGENTS.md for each agent with role + scope
2. Set up shared directory structure
3. Define reporting cadence
4. Run first task cycle
5. Review and adjust roles/communication

Quick-Start Templates

Solo Founder Starter Pack (3 agents)

CEO (Strategic) — Owns vision, priorities, decision gates PM (Coordination) — Translates goals into tasks, tracks progress Engineer (Execution) — Builds, tests, ships

Content Machine (4 agents)

Strategist — Topic research, audience analysis, content calendar Writer — Draft production, SEO optimization Editor — Quality review, brand voice consistency Publisher — Distribution, scheduling, performance tracking

Research & Analysis (4 agents)

Data Collector — Gather raw data from sources Analyst — Process, analyze, identify patterns Synthesizer — Produce actionable reports Monitor — Track changes, alert on anomalies

Anti-Patterns (Learn from Our Mistakes)

Anti-Pattern	Why It Fails	Fix
Agent with 5+ responsibilities	Context thrashing, low quality	Split into specialized agents
All-to-all communication	Message chaos, conflicts	Hub-and-spoke or hierarchical
No escalation path	Decisions stall, work stops	Define clear human escalation triggers
Copy-paste between agents	Knowledge silos, inconsistency	Shared knowledge base or wiki
Agents making strategic decisions	Misaligned with human intent	Agents propose, humans dispose

Platform Compatibility

This skill is platform-agnostic. The principles apply to:

• OpenClaw — Native multi-agent with sessions_send, shared dirs, cron
• Claude Code — Multiple sessions with file-based coordination
• Codex — Task files and workspace sharing
• Cursor — Agent rules files (.cursor/rules/) with workspace coordination

Real-World Case Study

晟瑞智联 AI Team (13 agents, OpenClaw)

                    ┌─────────┐
                    │   于哥   │  (Human CEO)
                    └────┬────┘
                         │
                    ┌────┴────┐
                    │  老A    │  (CEO Agent / Strategic)
                    │  Friday │  (Executive Assistant)
                    └────┬────┘
                         │
          ┌──────────────┼──────────────┐
          │              │              │
     ┌────┴────┐   ┌────┴────┐   ┌────┴────┐
     │  艾琳   │   │  瓦里斯  │   │  唐    │
     │ (PM)    │   │(Engineer)│   │(Writer) │
     └────┬────┘   └────┬────┘   └────┬────┘
          │              │              │
     ┌────┴────┐   ┌────┴────┐   ┌────┴────┐
     │Simons   │   │  小E    │   │  +6     │
     │(Analyst)│   │(Monitor)│   │specialists│
     └─────────┘   └─────────┘   └─────────┘

Communication: Shared directories for async, sessions_send for real-time, cron-based heartbeat for monitoring.

References

• Team Roles: references/team-roles.md — Complete role templates with AGENTS.md examples
• Communication: references/communication-patterns.md — Protocols, file structures, message formats
• Task Management: references/task-management.md — Tracking systems, report formats, escalation rules