os-improvement-loop

name	os-improvement-loop
version	0.5.0
description	Pattern 5: Concurrent Event-Driven Multi-Agent Loop. Coordinates multiple Claude sessions as OS threads sharing a common event bus and memory address space. Every loop cycle is a full improvement cycle: execute, eval against benchmark (KEEP/DISCARD), emit friction events during work, close with post_run_metrics, agent self-assessment survey saved to retrospectives, memory persistence, and Triple-Loop Retrospective trigger if friction threshold crossed. Four coordination topologies: turn-signal, fan-out, request-reply, triple-loop (Pattern D).
status	active
trigger	concurrent agents, shared event log, parallel agents, turn signal, fan-out, request-reply, background task shared state, event-driven agents, agent threads, kernel event bus, cross-session coordination, replace AGENT_COMMS, concurrent skill audit, claim task, inner agent, orchestrator peer agent, worker agent, continuous improvement loop, eval benchmark, self-assessment survey, post-run survey, friction events, metrics, Triple-Loop Retrospective, skill improvement, memory persistence, retrospective
allowed-tools	Read, Write, Edit, Bash, Glob, Grep

Concurrent Agent Loop

Pattern 5 in the agent-loops taxonomy. Treats concurrent Claude sessions as OS threads sharing a filesystem address space. The kernel event bus coordinates signals. Every cycle includes real work, eval against benchmark, friction tracking, agent self-assessment survey, post-run metrics, and memory persistence. The OS learns from every run.

---

Triple-Loop Architecture

There are two distinct Triple-Loop orchestration cycles operating at different scopes. Do not conflate them.

┌─────────────────────────────────────────────────────────┐
│  TRIPLE-LOOP ARCHITECT — OS Self-Improvement (this skill)       │
│                                                          │
│  os-improvement-loop evaluates and improves the OS       │
│  workflows, protocols, agent coordination patterns,      │
│  and this SKILL.md itself.                               │
│                                                          │
│  Target: the OS machinery — ledgers, surveys, kernel,    │
│  event bus, loop protocol.                               │
│  Eval gate: ORCHESTRATOR + PEER_AGENT run eval_runner.py │
│  on the OS skill being patched.                          │
│  Self-improvement: ORCHESTRATOR updates this SKILL.md    │
│  when a confirmed protocol fix is found.                 │
└────────────────────┬────────────────────────────────────┘
                     │ spawns / governs
┌────────────────────▼────────────────────────────────────┐
│  TRIPLE-LOOP EXECUTOR — Individual Skill Improvement           │
│                                                          │
│  os-eval-runner + os-skill-improvement evaluate and      │
│  improve a specific target SKILL.md (routing accuracy,   │
│  trigger descriptions, example blocks).                  │
│                                                          │
│  Target: a single skill's description and routing.       │
│  Eval gate: os-eval-runner scores the target skill.      │
│  Improvement: os-skill-improvement runs RED-GREEN-REFACTOR│
│  until score ≥ threshold.                                │
└─────────────────────────────────────────────────────────┘

Key distinction:

• The OUTER loop asks: "Is the OS improvement process itself working correctly?"
• The INNER loop asks: "Does this specific skill route and execute correctly?"

Triple-Loop Retrospective vs os-improvement-loop: Triple-Loop Retrospective (agent) is the trigger/diagnostic layer — it analyzes friction events, identifies improvement targets, and decides which Triple-Loop to invoke. os-improvement-loop (skill) is the execution protocol that agents follow once a target has been identified. Do not conflate them.

User: "run a continuous improvement loop on the os-eval-runner skill" ORCHESTRATOR reads last survey (notes INNER_AGENT flagged eval_runner.py flag confusion as biggest friction). Writes strategy packet incorporating that fix. INNER_AGENT runs, emits friction event when hitting the confusing flag, completes eval, saves survey noting the fix worked. PEER_AGENT runs os-eval-runner independently, produces KEEP verdict with score delta, saves survey noting zero friction. ORCHESTRATOR applies edit, runs post_run_metrics (friction count dropped from 3 to 0), writes session log with before/after scores, promotes fix to memory.md. No Triple-Loop Retrospective trigger needed — friction threshold not crossed. User: "audit 3 skills in parallel" ORCHESTRATOR dispatches 3 INNER_AGENTs via claim_task. Each emits friction events during work, runs eval_runner.py, saves survey. ORCHESTRATOR collects all results, identifies lowest scorer, writes correction packet. After correction cycle, runs post_run_metrics — 4 friction events for same cause (wrong CLI syntax in eval_runner). Triggers Triple-Loop Retrospective Full Loop to patch eval_runner documentation in the skill. Closes with session log and memory promotion. User: "replace AGENT_COMMS.md with the event bus and track whether it's faster" ORCHESTRATOR establishes bus, runs Pattern A turn-signal cycle, records round-trip latency. INNER_AGENT and PEER_AGENT both complete post-run surveys noting any friction with polling syntax. post_run_metrics emitted. Session log records latency delta vs AGENT_COMMS baseline. Surveys compared — if both agents report same confusion point, Triple-Loop Retrospective patches SKILL.md.