Swarm Anti Drift

Swarm Anti-Drift

Purpose

When multiple sub-agents work in parallel, they can drift — producing contradictory designs, duplicate code, or conflicting decisions. This skill defines the coordination contract that prevents drift in Cornerstone swarms.

When to Trigger

• 2+ agents working on the same codebase simultaneously
• Long multi-step tasks (5+ tool calls) where context may fragment
• Any task requiring consensus across architectural boundaries
• After agent failures or context resets in a long session

When to Skip

• Single-agent tasks
• Simple sequential workflows (one agent hands off to the next with no parallel work)
• Quick exploration or read-only investigation

Anti-Drift Protocol

1. Topology — Hierarchical by Default

Orchestrator (Queen)
    ├── Architect   → design decisions only
    ├── Coder(s)    → implementation (read Architect's output first)
    └── Reviewer    → validates against Architect's spec

• The Orchestrator holds the authoritative task graph.
• Workers MUST read shared memory before starting.
• Workers MUST write results to shared memory when done.
• Never let two workers modify the same file without a consensus gate.

2. Consensus — Raft-Style (Leader + Quorum)

Cornerstone uses an informal raft contract:

Rule: If two workers produce conflicting outputs, the Reviewer picks the one aligned with the current ADR. If no ADR exists, pause and invoke the adr-writer skill before proceeding.

3. Checkpoint Intervals

Every 10 sub-tasks, the Orchestrator MUST:

1. Retrieve all worker memory: retrieve_memory(namespace="swarm-checkpoints")
2. Verify architectural consistency against the active ADR.
3. Reconcile conflicts before continuing.
4. Store checkpoint: store_memory(key="checkpoint-N", namespace="swarm-checkpoints")

4. Shared Memory Namespaces

5. Agent Count Limit

Keep active parallel agents to ≤ 6 for coordination coherence. Beyond 6, the overhead of consensus outweighs the parallelism benefit.

3-Tier Model Routing

Route sub-tasks to the cheapest capable model to optimize cost and latency:

Decision rule: Start at Tier 1. Escalate only when the task requires reasoning beyond mechanical transformation.

Concurrency Mandate

One message = ALL related operations. Batch everything:

• All parallel agent spawns in one message
• All independent file reads in one message
• All memory store/retrieve operations in one message
• All terminal operations that can run simultaneously in one Bash call

Never wait for one agent to finish before spawning another if they are independent.

Integration with Cornerstone Orchestrator

The core/orchestrator skill already implements the memory-first pattern. This skill adds the anti-drift contract on top:

Orchestrator.start()
    → retrieve_memory("swarm-checkpoints")   # resume if prior run exists
    → spawn agents (parallel, ≤ 6)
    → checkpoint every 10 sub-tasks
    → Reviewer veto gate before merge
    → store_memory("checkpoint-final")
    → learning-protocol for new patterns

References

• Cornerstone Orchestrator: .agents/skills/core/orchestrator/SKILL.md
• ADR-0038: Ruflo-Inspired Agentic Infrastructure Integration
• ADR-0019: Swarm E2E Evaluations