Agent Orchestration Skill

Agent Orchestration

Comprehensive patterns for building and coordinating AI agents -- from single-agent reasoning loops to multi-agent systems and framework selection. Each category has individual rule files in rules/ loaded on-demand.

Quick Reference

| Category | Rules | Impact | When to Use | |----------|-------|--------|-------------| | Agent Loops | 2 | HIGH | ReAct reasoning, plan-and-execute, self-correction | | Multi-Agent Coordination | 3 | CRITICAL | Supervisor routing, agent debate, result synthesis | | Alternative Frameworks | 3 | HIGH | CrewAI crews, AutoGen teams, framework comparison | | Multi-Scenario | 2 | MEDIUM | Parallel scenario orchestration, difficulty routing |

Total: 10 rules across 4 categories

Quick Start

# ReAct agent loop
async def react_loop(question: str, tools: dict, max_steps: int = 10) -> str:
    history = REACT_PROMPT.format(tools=list(tools.keys()), question=question)
    for step in range(max_steps):
        response = await llm.chat([{"role": "user", "content": history}])
        if "Final Answer:" in response.content:
            return response.content.split("Final Answer:")[-1].strip()
        if "Action:" in response.content:
            action = parse_action(response.content)
            result = await tools[action.name](*action.args)
            history += f"\nObservation: {result}\n"
    return "Max steps reached without answer"

# Supervisor with fan-out/fan-in
async def multi_agent_analysis(content: str) -> dict:
    agents = [("security", security_agent), ("perf", perf_agent)]
    tasks = [agent(content) for _, agent in agents]
    results = await asyncio.gather(*tasks, return_exceptions=True)
    return await synthesize_findings(results)

Agent Loops

Patterns for autonomous LLM reasoning: ReAct (Reasoning + Acting), Plan-and-Execute with replanning, self-correction loops, and sliding-window memory management.

Key decisions: Max steps 5-15, temperature 0.3-0.7, memory window 10-20 messages.

Multi-Agent Coordination

Fan-out/fan-in parallelism, supervisor routing with dependency ordering, conflict resolution (confidence-based or LLM arbitration), result synthesis, and CC Agent Teams (mesh topology for peer messaging in CC 2.1.33+).

Key decisions: 3-8 specialists, parallelize independent agents, use Task tool (star) for simple work, Agent Teams (mesh) for cross-cutting concerns.

Alternative Frameworks

CrewAI hierarchical crews with Flows (1.8+), OpenAI Agents SDK handoffs and guardrails (0.12+), Microsoft Agent Framework (AutoGen + SK merger), GPT-5.2-Codex for long-horizon coding, and AG2 for open-source flexibility.

Key decisions: Match framework to team expertise + use case. LangGraph for state machines, CrewAI for role-based teams, OpenAI SDK for handoff workflows, MS Agent for enterprise compliance.

Multi-Scenario

Orchestrate a single skill across 3 parallel scenarios (simple/medium/complex) with progressive difficulty scaling (1x/3x/8x), milestone synchronization, and cross-scenario result aggregation.

Key decisions: Free-running with checkpoints, always 3 scenarios, 1x/3x/8x exponential scaling, 30s/90s/300s time budgets.

Key Decisions

| Decision | Recommendation | |----------|----------------| | Single vs multi-agent | Single for focused tasks, multi for decomposable work | | Max loop steps | 5-15 (prevent infinite loops) | | Agent count | 3-8 specialists per workflow | | Framework | Match to team expertise + use case | | Topology | Task tool (star) for simple; Agent Teams (mesh) for complex | | Scenario count | Always 3: simple, medium, complex |

Common Mistakes

No step limit in agent loops (infinite loops)
No memory management (context overflow)
No error isolation in multi-agent (one failure crashes all)
Missing synthesis step (raw agent outputs not useful)
Mixing frameworks in one project (complexity explosion)
Using Agent Teams for simple sequential work (use Task tool)
Sequential instead of parallel scenarios (defeats purpose)

Related Skills

ork:langgraph - LangGraph workflow patterns (supervisor, routing, state)
function-calling - Tool definitions and execution
ork:task-dependency-patterns - Task management with Agent Teams workflow

Capability Details

react-loop

Keywords: react, reason, act, observe, loop, agent Solves:

Implement ReAct pattern
Create reasoning loops
Build iterative agents

plan-execute

Keywords: plan, execute, replan, multi-step, autonomous Solves:

Create plan then execute steps
Implement replanning on failure
Build goal-oriented agents

supervisor-coordination

Keywords: supervisor, route, coordinate, fan-out, fan-in, parallel Solves:

Route tasks to specialized agents
Run agents in parallel
Aggregate multi-agent results

agent-debate

Keywords: debate, conflict, resolution, arbitration, consensus Solves:

Resolve agent disagreements
Implement LLM arbitration
Handle conflicting outputs

result-synthesis

Keywords: synthesize, combine, aggregate, merge, summary Solves:

Combine outputs from multiple agents
Create executive summaries
Score confidence across findings

crewai-patterns

Keywords: crewai, crew, hierarchical, delegation, role-based, flows Solves:

Build role-based agent teams
Implement hierarchical coordination
Use Flows for event-driven orchestration

autogen-patterns

Keywords: autogen, microsoft, agent framework, teams, enterprise, a2a Solves:

Build enterprise agent systems
Use AutoGen/SK merged framework
Implement A2A protocol

framework-selection

Keywords: choose, compare, framework, decision, which, crewai, autogen, openai Solves:

Select appropriate framework
Compare framework capabilities
Match framework to requirements

scenario-orchestrator

Keywords: scenario, parallel, fan-out, difficulty, progressive, demo Solves:

Run skill across multiple difficulty levels
Implement parallel scenario execution
Aggregate cross-scenario results

scenario-routing

Keywords: route, synchronize, milestone, checkpoint, scaling Solves:

Route tasks by difficulty level
Synchronize at milestones
Scale inputs progressively

Agent Skills: Agent Orchestration

Install this agent skill to your local

Skill Files