# C21 — The World: the meta-level is the product

**Guarantee.** Above the harness (C12's disjoint sim unit) sits the **World** — the
project's program / "game" (a Rust crate, C16). Within it, **harnesses are
dynamically constructible, first-class objects**: meta-programs (walk-forward,
sweep, optimize, Monte-Carlo — C12's orchestration axes) construct harness
instances at runtime via the bootstrap (C19), run them disjointly in parallel
(C1), aggregate / compare their results, and discard the transient instances. A
walk-forward rolls windows → bootstraps a harness per window → stitches
out-of-sample equity + parameter stability into one meta-result. Orchestrating
*families* of harnesses is **first-class**, not a headless afterthought; the run
registry (C18) is the World's memory. A harness's **topology is a serializable
data value the World owns** (C24), not Rust source — the precondition for the
World's full ambition: it can **generate**, **mutate**, **structurally search**
(genetic / NEAT-style graph operators), **compare**, and
**serialize-for-reproduction** (C18) *families that vary structure*, not only
numeric params. A param sweep over a fixed skeleton is the degenerate case;
varying the skeleton itself needs topology-as-value. (#109, resolved 2026-06-29.)

**Forbids.** Relegating multi-harness orchestration (walk-forward / sweep /
comparison) to second-class headless-only status; treating the single backtest as
the product.

**Why.** What happens *within* one harness — backtest a strategy → equity — is
commodity; every quant system covers it. aura exists for the meta-level: a
programmable space where harnesses are dynamically built and families of them
orchestrated and explored. The deterministic single-harness engine (C1–C20) is
the **substrate**; the World is the **product**. The game-engine principle (C16)
made literal: the engine owns the scene / blueprint graph as content, instantiates
and runs it, the way aura owns harness topology as data (C24).

## Current state

The four orchestration axes (sweep, walk-forward, Monte-Carlo, generalize) are
realized as families the World constructs, runs disjointly (C1), and aggregates.
The dissolved orchestration verbs translate each invocation into a
content-addressed process + campaign document, run through a single campaign
executor (`aura-campaign`, driven by `aura-runner`), so every ad-hoc family run is
durable, diffable, reproducible intent rather than a bespoke code path per verb.
Harness topology is a World-owned serializable data value (C24): blueprints are
JSON that the bootstrap (C19) compiles to a flat instance (C23); the run registry
(C18) persists each run's manifest as the World's memory, and any family member is
re-derivable from that manifest.

The **programmable analysis meta-level** is only partly realized. Families are
*produced* and *compared* (the trace explorer's family view, C22) but are not yet
themselves **composable** — sweep / MC / walk-forward as first-class meta-level
operators one can nest and pipe — and the structural-search ambition (generate /
mutate / genetic / NEAT-style graph operators over topology-as-value) is not built.
That is the open search-policy direction; today the World constructs fixed family
shapes rather than searching over the space of shapes.

## See also
- [C24](c24-blueprint-data.md) — harness topology as a World-owned data value
- [C16](c16-engine-project-split.md) — the engine / project split and the game-engine principle
- [C12](c12-atomic-sim-unit.md) — the atomic sim unit and the four orchestration axes
- [C19](c19-bootstrap.md) — blueprint → instance bootstrap
- [C18](c18-registry.md) — the run registry, the World's memory
- [C22](c22-playground-traces.md) — the trace explorer that plays these families