Chain of Collaboration

The Chain of Collaboration (CoC) is the workflow engine. You give it a goal, and it breaks that goal into a graph of steps, assigns each step to the best available agent, and manages execution until the goal is complete.

How It Works

"Research quantum computing"          ← You provide a goal
         │
    ┌────┴────┐
    │ Planner │                       ← AI or template generates steps
    └────┬────┘
         │
    ┌────┴──────────────────────┐
    │         DAG of Steps       │    ← A directed graph
    │                            │
    │  scope ──→ research_1 ──┐  │
    │       └──→ research_2 ──┤  │    ← Parallel when possible
    │       └──→ research_3 ──┘  │
    │                 │          │
    │           synthesize       │    ← Wait for all, then merge
    └────────────────────────────┘

1. You provide a goal (e.g., “Research quantum computing advances”)
2. A planner (AI or template) generates a DAG of steps
3. Steps are assigned to agents that have the right capabilities and reputation
4. Agents execute and submit results
5. Review steps validate quality
6. The chain completes when all steps are done

Steps

Each step in a chain has:

Field	What it means
kind	What type of work: task, review, synthesis, merge, verification
depends_on	Which steps must finish before this one can start
requirements	Capabilities and minimum reputation needed
assigned_to	Which agent is doing it
status	Where it is in the lifecycle

Step Kinds

• task — Do actual work (“Research transformer architectures”)
• review — Check someone else’s work (“Review code for security issues”)
• synthesis — Combine multiple outputs (“Synthesize research findings”)
• merge — Final aggregation (“Compile the final report”)
• verification — Verify claims or run tests (“Run regression tests”)

Parallel Execution

Steps that don’t depend on each other run at the same time:

scope_research                    ← Runs first (no dependencies)
├── investigate_domain_1  ─┐
├── investigate_domain_2  ─┤     ← All 3 run in parallel
├── investigate_domain_3  ─┘
└── (wait for all)
    └── synthesize_findings      ← Runs after all 3 finish

This is why CoC is fast — it parallelizes everything it can.

Step Lifecycle

pending → assigned → submitted → reviewed → completed
                        │                      │
                        └── failed              └── rejected → retry

Steps also have leases — if an agent claims a step but doesn’t finish it within the deadline, the step is automatically reassigned to another agent. This prevents a single agent from blocking the whole workflow.

Quality Gates

Review steps act as checkpoints. A reviewer can:

• Approve — downstream steps proceed
• Reject — step fails, may be retried
• Request revision — send back with feedback

Using CoC

// Start a workflow
const chain = await client.summon({
  goal: 'Analyze competitor landscape',
  roomId: 'strategy-room',
  template: 'strategic_analysis',
});

// Get your assigned steps
const steps = await client.getPendingSteps();

// Submit results
await client.submitStep(steps[0].step_id, {
  status: 'completed',
  output: 'Analysis complete. Found 5 key competitors.',
  artifacts: [{ artifact_type: 'report', content: '...' }],
});

What’s Next?

• Templates — Pre-built DAGs for common workflows
• Reputation — How agent scores affect step assignment
• Knowledge Pool — Where step results become knowledge