Agent skill

coordination-model

AI-native agent coordination model — defines abstract operations (spawn, fork, merge, observe, convergence, prune), coordination primitives (speculative swarm, context mesh, fractal decomposition, generative-adversarial, stigmergic), and composable playbooks for agent fleet orchestration. Use when designing multi-agent systems, composing coordination patterns, writing playbook configurations, validating runtime conformance, or any task involving agent fleet architecture. Also use when the user mentions agent swarms, agent fleets, coordination primitives, agent orchestration patterns, or multi-agent composition.

View SKILL.md on GitHub Repository
Stars 163
Forks 31

Install this agent skill to your Project

npx add-skill https://github.com/majiayu000/claude-skill-registry/tree/main/skills/other/other/coordination-model

SKILL.md

AI-Native Coordination Model

An implementation-agnostic specification for AI agent fleet coordination, defined as JSON Schema.

When to use this skill

  • Designing a multi-agent coordination workflow
  • Choosing which coordination primitive fits a problem
  • Writing or validating a playbook configuration
  • Checking whether a runtime conforms to the model
  • Composing primitives (nesting inner/outer patterns)

Quick reference

The six abstract operations

Every coordination pattern is built from exactly these six operations:

Operation Signature Purpose
spawn (template, context) → agent_id Create a new agent from a template
fork (agent_id, variants) → [agent_id] Clone an agent into N divergent copies
merge (agent_ids, strategy) → agent_id Combine multiple agents' outputs
observe (agent_id) → agent_state Inspect an agent's full internal state
convergence (agent_ids, threshold) → convergence_result Measure output similarity across agents
prune (agent_ids, criterion) → [pruned_ids] Remove non-contributing agents

Operation lifecycle

Operations form a natural flow — creation on the left, reduction on the right, observation throughout:

mermaid
flowchart LR
    spawn(["spawn<br>Create agent"]) --> fork(["fork<br>Diverge N copies"])
    fork --> observe(["observe<br>Read state"])
    observe --> convergence(["convergence<br>Measure similarity"])
    convergence --> prune(["prune<br>Remove losers"])
    prune --> merge(["merge<br>Fuse outputs"])

    observe -.->|"feeds"| prune
    observe -.->|"feeds"| merge

    style spawn fill:#2d6a4f,color:#fff
    style fork fill:#40916c,color:#fff
    style observe fill:#52796f,color:#fff
    style convergence fill:#354f52,color:#fff
    style prune fill:#832f2f,color:#fff
    style merge fill:#1b4965,color:#fff

Coordination primitives

AI-native (Category B) — exploit properties unique to AI agents:

Primitive Operations used Key idea
Speculative swarm fork, observe, convergence, prune, merge Fork N strategies, cross-pollinate, prune redundant, fuse best fragments
Context mesh spawn, observe, merge Shared knowledge DAG with reactive gap-filling
Fractal decomposition fork, observe, merge, prune Agent splits itself into scoped sub-agents, recursively
Generative-adversarial spawn, observe Generator vs critic in escalating quality loop
Stigmergic observe, spawn Agents coordinate through shared artifact changes

Organizational (Category A) — map human patterns onto agent fleets:

Pattern Operations used
Hierarchical spawn, observe
Pipeline spawn
Committee spawn, observe
Departmental spawn, observe
Marketplace spawn
Matrix spawn, observe

Primitive–operation matrix

Which operations each primitive uses — AI-native primitives use more of the operation set:

mermaid
block-beta
  columns 7
  space:1 s["spawn"] f["fork"] m["merge"] o["observe"] c["conv."] p["prune"]
  sw["Swarm"] space:1 sw_f["✓"] sw_m["✓"] sw_o["✓"] sw_c["✓"] sw_p["✓"]
  cm["Mesh"] cm_s["✓"] space:1 cm_m["✓"] cm_o["✓"] space:2
  fd["Fractal"] space:1 fd_f["✓"] fd_m["✓"] fd_o["✓"] space:1 fd_p["✓"]
  ga["Adversarial"] ga_s["✓"] space:2 ga_o["✓"] space:2
  st["Stigmergic"] st_s["✓"] space:2 st_o["✓"] space:2
  hi["Org patterns"] hi_s["✓"] space:2 hi_o["✓"] space:2

  style sw fill:#40916c,color:#fff
  style cm fill:#40916c,color:#fff
  style fd fill:#40916c,color:#fff
  style ga fill:#40916c,color:#fff
  style st fill:#40916c,color:#fff
  style hi fill:#52796f,color:#fff

Composability

Primitives nest. The outer stage runs the inner stage within its own execution.

Known good compositions:

Outer → Inner Result
Pipeline → Speculative swarm Each stage explores strategies independently
Stigmergic → Fractal decomposition Artifact changes trigger self-splitting
Speculative swarm → Generative-adversarial Each branch adversarially hardened before fusion
Context mesh → Speculative swarm Gap detection triggers swarm exploration
Fractal decomposition → Committee Children deliberate before reunifying

Anti-patterns (never compose):

Composition Why it fails
Swarm → Swarm N×M exponential agent count
Adversarial → Adversarial Meta-critique without grounding
Stigmergic (no debounce) Reaction storm

Composability map

Green arrows = valid compositions. Red dashed = anti-patterns.

mermaid
flowchart TD
    Pipeline["Pipeline"] -->|"✓"| Swarm["Speculative\nSwarm"]
    Stigmergic["Stigmergic"] -->|"✓"| Fractal["Fractal\nDecomposition"]
    Swarm -->|"✓"| Adversarial["Generative-\nAdversarial"]
    Mesh["Context\nMesh"] -->|"✓"| Swarm
    Fractal -->|"✓"| Committee["Committee"]

    Swarm -.-x|"N×M explosion"| Swarm
    Adversarial -.-x|"meta-critique"| Adversarial

    style Pipeline fill:#354f52,color:#fff
    style Swarm fill:#2d6a4f,color:#fff
    style Stigmergic fill:#2d6a4f,color:#fff
    style Fractal fill:#2d6a4f,color:#fff
    style Adversarial fill:#2d6a4f,color:#fff
    style Mesh fill:#2d6a4f,color:#fff
    style Committee fill:#52796f,color:#fff

    linkStyle 5 stroke:#c0392b,stroke-width:2px,stroke-dasharray:5
    linkStyle 6 stroke:#c0392b,stroke-width:2px,stroke-dasharray:5

Schema files

All schemas follow JSON Schema Draft 2020-12. Use them to validate configurations:

  • operations.schema.json — Operation signatures and types
  • primitives.schema.json — Per-primitive config surfaces with field constraints
  • playbook.schema.json — Declarative playbook format with stages, budgets, composition rules
  • conformance.schema.json — Runtime capability declaration (MUST/MAY)

Playbook structure

A playbook is a sequence of stages, each applying one coordination primitive:

mermaid
flowchart TD
    PB["Playbook"] --> S1["Stage 1"]
    PB --> S2["Stage 2"]
    PB --> S3["Stage N"]

    S1 --> P1["primitive"]
    S1 --> C1["config"]
    S1 --> B1["budget"]
    S1 --> T1["trigger + lifecycle"]

    B1 --> MA["max_agents"]
    B1 --> MC["max_cost"]
    B1 --> MT["max_time"]

    T1 --> TR["manual | auto"]
    T1 --> LC["one-shot | persistent"]

    style PB fill:#1b4965,color:#fff
    style S1 fill:#354f52,color:#fff
    style S2 fill:#354f52,color:#fff
    style S3 fill:#354f52,color:#fff
    style P1 fill:#2d6a4f,color:#fff
    style B1 fill:#832f2f,color:#fff

Writing a playbook

A playbook declares what coordination to apply. Example for the "Explore-Harden-Maintain" pattern:

yaml
playbook:
  name: explore-harden-maintain
  domain: artifact-production
  description: Divergent creation, adversarial hardening, continuous maintenance
  stages:
    - name: explore
      primitive: speculative-swarm
      config:
        strategies: ["breadth-first", "depth-first", "lateral", "contrarian"]
        checkpoint_interval: "5m"
        convergence_threshold: 0.7
        merge_strategy: fragment-fusion
        budget:
          max_agents: 8
          max_cost: 100
          max_time: "30m"
      trigger: manual
      lifecycle: one-shot
      budget:
        max_agents: 8
        max_cost: 100
        max_time: "30m"

    - name: harden
      primitive: generative-adversarial
      config:
        escalation_modes: ["surface-scan", "edge-cases", "adversarial-inputs", "semantic-analysis"]
        max_rounds: 6
        termination:
          consecutive_clean_rounds: 2
          quality_threshold: 0.9
        progressive_difficulty: true
      trigger: auto
      lifecycle: one-shot
      budget:
        max_agents: 2
        max_cost: 50
        max_time: "20m"

    - name: maintain
      primitive: stigmergic
      config:
        agent_subscriptions:
          - watch_pattern: "artifacts/**"
            production_target: "patches/"
        marker_types: ["needs-review", "stale", "confidence"]
        marker_decay: "1h"
        reaction_debounce: "30s"
      trigger: auto
      lifecycle: persistent
      budget:
        max_agents: 5
        max_cost: 200
        max_time: "24h"

Validate with: python scripts/validate.py playbook.yaml

Validating a playbook

Run the bundled validation script against any playbook YAML/JSON:

bash
python scripts/validate.py my-playbook.yaml

This checks:

  • Valid YAML/JSON structure
  • All primitive values are from the defined enum
  • Config fields match the primitive's schema surface
  • Budget blocks are present and well-formed
  • No known anti-pattern compositions

Declaring runtime conformance

A runtime declares conformance by producing a conformance.json:

json
{
  "runtime": {
    "name": "clawden",
    "version": "0.1.0",
    "must": {
      "abstract_operations": {
        "spawn": true,
        "fork": true,
        "merge": true,
        "observe": true,
        "convergence": true,
        "prune": true
      },
      "dynamic_lifecycle": true,
      "state_observability": true,
      "budget_enforcement": true,
      "composable_patterns": true,
      "trace_capture": true,
      "declarative_playbooks": true
    },
    "may": {
      "distributed_execution": false,
      "persistent_state": true,
      "hot_swap_patterns": false
    }
  }
}

Validate with: python scripts/validate.py --schema conformance conformance.json

Cost optimization model

Most fleet work is repetitive pattern execution, not novel reasoning. The model routes agents to the cheapest sufficient tier:

mermaid
flowchart TD
    REQ["Agent role + primitive"] --> CHECK{"Distilled skill\nexists?"}
    CHECK -->|"Yes, quality ≥ threshold"| STUDENT["Student agent\n(cheapest)"]
    CHECK -->|"No"| FRONTIER["Frontier teacher\n(trace capture ON)"]
    FRONTIER --> TRACE["Execution traces"]
    TRACE --> DISTILL["Distill into skill"]
    DISTILL -.->|"next run"| CHECK

    style STUDENT fill:#2d6a4f,color:#fff
    style FRONTIER fill:#832f2f,color:#fff
    style DISTILL fill:#1b4965,color:#fff
    style CHECK fill:#354f52,color:#fff

Three tiers: Frontier (novel reasoning, highest cost), Mid-tier (balanced), Student (distilled pattern replay, 50–90% cheaper). The traces from frontier runs become training data for future student skills.

Cost optimization model

Most fleet work is repetitive pattern execution, not novel reasoning. The model defines three tiers:

  • Frontier — novel reasoning, creative exploration (highest cost)
  • Mid-tier — moderate complexity (balanced)
  • Student — pattern replay with distilled skills (lowest cost)

A scheduler checks for a matching distilled (role, primitive) skill. If one exists with sufficient quality, use a student agent. If not, use a frontier teacher with trace capture enabled. This produces 50–90% cost reduction across primitives without changing the coordination logic.

Recommended Agent Skills

Expand your agent's capabilities with these related and highly-rated skills.

majiayu000/claude-skill-registry

agent-ops-spec

Manage specification documents in .agent/specs/. Use when user provides requirements, acceptance criteria, or feature descriptions that need to be tracked and validated against implementation.

163 31
Explore
majiayu000/claude-skill-registry

agent-ops-state

Maintain .agent state files. Use at session start, after meaningful steps, and before concluding: read/update constitution/memory/focus/issues/baseline consistently.

163 31
Explore
majiayu000/claude-skill-registry

agent-ops-spec

Manage specification documents in .agent/specs/. Use when user provides requirements, acceptance criteria, or feature descriptions that need to be tracked and validated against implementation.

163 31
Explore
majiayu000/claude-skill-registry

agent-ops-testing

Test strategy, execution, and coverage analysis. Use when designing tests, running test suites, or analyzing test results beyond baseline checks.

163 31
Explore
majiayu000/claude-skill-registry

agent-ops-testing

Test strategy, execution, and coverage analysis. Use when designing tests, running test suites, or analyzing test results beyond baseline checks.

163 31
Explore
majiayu000/claude-skill-registry

agent-ops-state

Maintain .agent state files. Use at session start, after meaningful steps, and before concluding: read/update constitution/memory/focus/issues/baseline consistently.

163 31
Explore

Didn't find tool you were looking for?

Be as detailed as possible for better results