3 — World: The Runtime Model

The world is what exists inside the running Colibri server. When the process boots, it creates an in-memory reality governed by laws, populated by agents, and executing work according to a pipeline. This section describes that reality.

The world has three sub-worlds that correspond directly to the three axes: physics (the laws that constrain what can happen), social (the agents that interact in the system), and execution (how work actually flows from idea to completion). These are not independent domains that can be understood separately. They are three views of a single unified system. Every mutation passes through all three: it must be validated by physics, attributed to a social agent, and executed through the pipeline.

Phase 0 ships (from 3-world):

execution/: β task-pipeline (8-state FSM, 8 tools), ε skill-registry read-only (skill_list), ζ decision-trail (4 tools + hash chain), α middleware (5 stages).

physics/laws/: η proof-store (Merkle, 2 tools).

physics/enforcement/: input validation + injection detection only (s13 HS-01).

social/: surfaces (repo/worktrees/Obsidian/Pages contracts).

Not in Phase 0 (spec only, activates later rounds):

physics/laws/consensus (R121+) · rule-engine (R81+) · state-fork (R151+)

physics/enforcement/governance (R151+) · integrity (R151+)

social/identity (R216+) · reputation (R101+) · llm router (R91+)

See ../5-time/roadmap.md for phase-by-phase activation.

The Three Sub-Worlds

Physics: The Laws

The legitimacy axis is the physics of the runtime. It defines what is allowed to happen and why it remains true. The constitution (7 axioms, defined in s01) is immutable and cannot be violated. Built on top are laws that govern causality (κ Rule Engine), agreement (θ Consensus), branching (ι State Fork), and truth preservation (η Proof Store). There is also enforcement: an integrity monitor (μ) that detects violations, and a governance layer (π) where the laws themselves can be changed.

The middleware chain (5 stages in α System Core) is where physics is enforced. Every mutation enters through this gate. If it violates the laws, it does not execute.

Also part of physics: admission gates (s10, the rules for which agents can submit which tasks) and hardening (s13, the runtime protections that prevent state corruption).

Phase 0 implements η (Proof Store) and α (System Core). The rest is specified and comes later.

Concepts in physics:

α System Core — gateway, middleware chain, database transaction boundaries
η Proof Store — Merkle tree, conservation of information, immutability
κ Rule Engine (Phase 1) — deterministic effects, forbidden operations
θ Consensus (Phase 3) — collective agreement on state
ι State Fork (Phase 5) — parallel realities, branching protocol
μ Integrity Monitor (Phase 4) — misbehavior detection
π Governance (Phase 6) — how the laws change

The social world is who is in the system and how they interact. There is a four-tier agent hierarchy: Human (T0, the owner) → Sigma (T1, the orchestrator) → PM (T2, the project manager) → Executor (T3, the worker) → Model (T4, Claude in Phase 0). Each tier has a role and a contract.

There are also permanent identities with reputation (λ Reputation in Phase 2). In later phases, agents carry a soul vector (ξ Identity in Phase 8) that persists across forks and can be cryptographically verified.

The social world also has a topology: four surfaces (repo → worktrees → Obsidian → GitHub Pages) where agents collaborate and leave traces.

Concepts in social:

Four-tier hierarchy (documented in colibri-system.md §4)
δ Model Router (Phase 1.5) — where to send work
ε Skill Registry — what agents know how to do
λ Reputation (Phase 2) — who can be trusted
ξ Identity (Phase 8) — persistent soul vector, cryptographic binding

Execution: How Work Flows

The execution axis is the pipeline. Work arrives as a task, is processed through an 8-state FSM (β Task Pipeline), leaves a decision trail (ζ), and is sealed with a Merkle proof (η). Skills (ε) define what the system can do. Thought records (ζ) form an auditable chain of reasoning.

The 5-step executor chain (audit → contract → packet → implement → verify) is the human-facing workflow that maps onto the β FSM. When a human executor picks up a task, they follow these five steps. Each step produces an artifact and a commit. By the time they reach step 5, the FSM has advanced through its states and left a trail of decisions.

Concepts in execution:

α System Core — the gateway and middleware
β Task Pipeline — the 8-state FSM and state transitions
γ Server Lifecycle — startup, shutdown, runtime modes
ε Skill Registry — capabilities, inventory, skill_list tool
ζ Decision Trail — hash-chained thought records
ν Integrations (Phase 0.9+) — repo, Obsidian, GitHub, stdio bridges

The Invariant: Every Mutation Touches All Three

This is the core principle that unifies the world:

Every mutation must be validated by physics, attributed to a social agent, and executed through the pipeline.

Example: A human executor submits a task.

Physics: The task entry passes through the α middleware chain. Schema validation (stage 2) ensures the task record is well-formed. The audit stage (3) records it. If any rule forbids this agent from submitting tasks (s10 admission), the task is rejected before it can execute.
Social: The task is attributed to a specific executor (an agent with an identity). When complete, the executor writes back a reflection via thought_record, and that record is anchored to the executor’s identity so reputation can be updated (Phase 2).
Execution: The task enters the β FSM in state INIT. It transits through GATHER → ANALYZE → PLAN → APPLY → VERIFY → DONE. Each transition is driven by a tool call (Task tool), which is itself a mutation that passes through physics again. The final state is DONE, and merkle_finalize seals the whole trace into the proof tree.

The same pattern holds for every tool call, every thought record, every state change. The three sub-worlds are interlocked.

What Comes Next

Physics — Deep dive into the seven axioms, the proof store, the rule engine, and the enforcement machinery.
Social — The four-tier hierarchy, reputation, identity, and the four-surface topology.
Execution — The task pipeline FSM, the skill registry, the decision trail, and how work flows end-to-end.

Each sub-world is fully specified in its own index. The Greek-letter concepts are documented across the World Schema layers (see world-schema.md).