Skip to content

Rally Driving in Plantangenet

Rally driving is the third proof domain alongside Pong and Music.

Where Pong asks: can a deterministic world host interchangeable agency? And Music asks: can an agent become aware of its participation in a structured field?

Rally driving asks:

Can an agent maintain coherent action while navigating multiple overlapping, partially reliable runway projections under constraint?

This document explains what rally driving means inside the Plantangenet architecture and why the Road, the Pace Notes, and the Driver matter as modeling choices, not just simulation components.

The Short Version

Inside Plantangenet, rally driving is a multi-runway constraint field.

It demonstrates that:

  • multiple future projections can coexist and compete
  • not all projections are equally reliable
  • action must be chosen under time pressure and physical limitation
  • self-model and trust become necessary for coherence

The architectural question remains the same:

Who is producing this agent’s next action, and what do they trust when choosing it?

From Single Runway to Many

In Pong:

  • one ball defines one future

In Music:

  • Pop and Jazz define a structured but unified field

In Rally:

  • the road defines many overlapping futures

At any moment, the Driver is navigating:

  • immediate trajectory (current vehicle state)
  • upcoming curvature (visible road)
  • announced future (pace notes)
  • inferred surface conditions (grip, slope, camber)
  • memory of past segments (learned expectation)

These are not always aligned.

The Driver does not receive a single runway. The Driver receives a bundle of projections.

What the Road Is

The Road is the primary field emitter.

It is not a mind. It does not choose. It does not evaluate.

It simply:

  • defines geometry (curvature, elevation, width)
  • exposes surface properties (grip, roughness, hazards)
  • reveals only what is visible from the current position

Like the ball in Pong and Pop in music, the Road:

  • evolves deterministically
  • exposes a partial future
  • defines where action will matter

But unlike Pong, the Road is occluded and incomplete.

The future exists, but the Driver cannot fully see it.

What the Pace Notes Are

Pace notes are secondary runway emitters.

They are:

  • projections of the future beyond visibility
  • structured, symbolic descriptions of upcoming segments
  • temporally aligned but not guaranteed to be perfect

They introduce a new dimension:

Not all runway projections are equally trustworthy.

Pace notes may be:

  • early or late
  • imprecise
  • mismatched to current speed or conditions

They are not truth. They are advice.

What the Car Is

The car is the constraint body.

It defines:

  • acceleration limits
  • braking capability
  • turning radius
  • stability envelope
  • failure modes (slip, drift, loss of control)

The car is analogous to the paddle’s velocity limits and the Musician’s expressive bandwidth.

It answers:

Even if I know what I should do, what am I physically capable of doing right now?

What the Driver Is

The Driver is the site of control and interpretation.

The Driver:

  • observes the Road (visible geometry)
  • receives Pace Notes (projected future)
  • senses the Car (current state and limits)
  • recalls past experience (trace and model)
  • chooses the next action

Like the paddle and the Musician, the Driver may be:

  1. Algorithmically driven — optimal racing line, reactive control
  2. Replay-driven (TAS) — precomputed perfect execution
  3. Creature-driven — self-model, dissonance, trust, and willful resolution
  4. Human-driven — external operator with subjective interpretation

The architecture remains unchanged. Only the source of the next action differs.

The Core Difficulty

Rally driving introduces a new problem not present in Pong or Music:

Projection conflict.

At any moment:

  • the visible road may suggest one action
  • the pace notes may suggest another
  • the car’s current state may constrain both

Example:

  • Pace note: “flat left”
  • Reality: wet gravel, reduced grip
  • Car: slightly off-line from previous corner

There is no single correct answer.

The Driver must decide:

  • which projection to trust
  • how much to commit
  • how to resolve disagreement

Dissonance in Rally

Dissonance becomes multi-domain and unavoidable.

1. Projection Dissonance

  • pace notes vs visible road
  • expectation vs reality

2. Capability Dissonance

  • intended trajectory vs achievable trajectory
  • braking distance exceeded

3. Temporal Dissonance

  • acting too early or too late
  • misaligned timing with the road

4. Trust Dissonance

  • “I followed the notes and it failed”
  • “I ignored the notes and it worked”

Unlike music, where dissonance can be aesthetic, in rally it is physical and immediate.

The Role of the Self-Model

A creature Driver must develop:

Constraint Model

  • braking limits
  • cornering limits
  • recovery patterns

Trust Model

  • reliability of pace notes
  • reliability of perception under speed
  • bias toward caution or aggression

Performance Model

  • where errors tend to occur
  • how the Driver behaves under pressure
  • patterns of over- or under-commitment

This is not about driving faster.

It is about:

maintaining coherence under conflicting information.

Commitment and Irreversibility

Rally introduces a critical property:

actions are often irreversible.

  • braking too late cannot be undone
  • entering a corner too fast propagates forward
  • small errors compound

This makes commitment windows central.

The Driver must:

  • decide when to commit
  • accept that commitment has consequences
  • manage future options based on past decisions

This is the strongest expression yet of willful resolution.

The Runway Model, Fully Generalized

Across all three domains:

  • Pong: one clean runway
  • Music: structured, shared runway
  • Rally: multiple, conflicting runways

Rally is where the runway abstraction becomes:

a set of competing, partially trusted futures

The agent’s job is no longer:

  • follow the runway

It becomes:

  • choose which runway to believe, and how strongly

What Is Already Implied

Given the existing Plantangenet architecture:

  • KNAT can publish road geometry, car state, and pace notes
  • multiple projections can exist as named subjects
  • trace can capture decision context per step
  • dissonance systems can expand to projection and trust domains
  • creature layers can arbitrate between competing signals

No new fundamental layer is required.

Only richer interpretation.

What Music Taught

The music proof domain (Pop Surface Context Graph, Phases I–V) was completed before racing development began in earnest. Several patterns from that work transfer directly.

Layer Decomposition Works

The PSCG uses a four-layer structure: P0 (beat grid) → P1 (phrase intent) → P2 (role guidance) → P3 (note-set candidates). Each layer is independently defined and independently testable by ablation.

Racing has an identical structure waiting to be made explicit:

  • P0 — road geometry grid: segment boundaries, curvature class, elevation
  • P1 — segment intent: braking zone character, apex type, exit energy
  • P2 — tactical instruction: pace notes as structured projection (the advisory layer)
  • P3 — trajectory candidates: specific approach shapes, keyed to segment type and commitment style

This is not an abstraction imposed from outside. It is the natural decomposition of what a Driver is already processing. Making it explicit makes it testable.

Named Agents Before Creature Layer

In music, four named Musicians (Strummer/Support, Caller/Lead, Floor/Anchor, Bell/Air) were run through the PSCG pipeline before any creature self-model was attempted. The proof was architectural: each layer had to demonstrably change behavior.

The same discipline applies to racing. Before building a Driver creature, build a named-driver harness. Give each named driver a fixed behavioral profile -- aggressive commitments, conservative entries, late-braking tendencies, early-apex bias. Run them through the track decomposition pipeline. Verify that different layers produce measurably different outcomes for each.

If the pipeline doesn't differentiate named drivers, it is not doing real architectural work. Build the harness first. Prove it. Then add the creature layer.

Trace Schema Is the Stable Contract

The music harness defined HarnessTraceRow early: a fixed schema capturing active section, phrase node, chord, role guidance, chosen action, rejected alternatives, dissonance before/after, seed cursor, precision level, and musician identity.

The racing equivalent should be designed with the same discipline before any other implementation:

  • active segment identifier
  • visible road curvature and grip estimate
  • pace note projection (what was announced)
  • car state summary (velocity, lateral load, slip estimate)
  • chosen action and rejected alternatives
  • projection delta (note vs visible discrepancy)
  • commitment window (frames remaining to change course)
  • driver identity and tick

This schema is not scaffolding. It is the metric vocabulary the creature layer will eventually internalize. Getting it right early prevents the creature from being built on top of an incoherent trace.

External Metrics Before Internal Self-Model

In music, scoring functions (role coherence, phrase boundary agreement, breakdown compliance) were implemented as an external library -- computable from any trace slice, independent of any particular run. The insight is that these same scores will eventually be available to the Musician's own self-model, not as external evaluation but as the raw material of its dissonance.

For racing, the equivalent metrics are:

  • projection coherence: how often the chosen action was consistent with the announced pace note vs the visible road
  • commitment alignment: how often the driver committed within the viable window
  • recovery compliance: how well the driver adapted after a projection mismatch

Implement these as external library functions first. They are what a Driver's PerformanceModel will eventually internalize. The harness is not the prototype for the creature -- it is the creature's future vocabulary, established early.

Ablation Is Architecture Proof

The music harness proved each PSCG layer was doing real work by ablation: removing P1 reduced phrase boundary agreement, removing P2 reduced role coherence. If a layer's removal didn't change the metrics, it wasn't load-bearing.

The same proof must hold for racing. Removing pace notes should measurably increase projection dissonance. Removing grip estimates should measurably increase capability dissonance. If neither ablation changes anything, the architecture is not using what it claims to use.

Do not build the creature layer on top of an ablation that does not pass.

Determinism From Seed

All music integration tests use a fixed seed to guarantee deterministic replay. Architecture changes produce measurable metric shifts rather than observational noise. This is essential for regression detection.

Racing must preserve the same property. A seeded Driver must produce an identical action trace across runs. The metrics on that trace are the baseline. Any architecture change that moves the metrics without an intentional design decision is a regression.

What Comes Next

Given the music lessons, the development path is ordered differently than it would otherwise appear:

First: layer decomposition

  • Define the four-layer projection structure (P0–P3 racing analog) as named types
  • Implement a reference track decomposition for a single known course
  • Represent pace notes as structured typed projections, not raw KNAT strings

Second: named-driver harness

  • Define DriverTraceRow (the stable trace schema)
  • Build three to four named drivers with fixed behavioral profiles
  • Run them through the track projection pipeline
  • Confirm the pipeline produces measurably different outcomes per driver

Example KNAT subjects, shaped by the trace schema rather than invented speculatively:

  • knat.rally.road.curvature.visible
  • knat.rally.road.curvature.projected
  • knat.rally.pacenote.next
  • knat.rally.car.velocity
  • knat.rally.car.grip_estimate

Third: external metrics

  • Implement compute_projection_coherence, compute_commitment_alignment, compute_recovery_compliance as a library module
  • Verify ablation: removing pace notes degrades projection coherence
  • Verify ablation: named drivers produce different scores

Fourth: creature layer

  • Only after the above passes: add Driver self-model, dissonance, willful resolution
  • The creature's PerformanceModel reads from the same metric vocabulary the harness uses

What Comes After That

Multi-agent rally.

  • co-driver and driver as separate agents
  • competing interpretations of the same field
  • negotiation of trust in real time

And beyond that:

Arkanoid generalized fully —

many signals, many futures, limited action bandwidth.

Takeaway

In Plantangenet rally driving:

  • the Road and Pace Notes are runway emitters with different visibility and reliability
  • the Car defines physical constraint and consequence
  • the Driver is an agent choosing between competing projections under pressure
  • the architecture matters because it allows these roles to remain separable while interacting tightly

Rally driving is the third proof:

a shared deterministic world can host not just multiple forms of agency, but multiple competing interpretations of the future — and agents that must decide what to trust.

That is where participation becomes judgment.