Skip to main content

Substrate primitives & behavioral probes

The NPG gate is the value test at the boundary. It stands on a set of substrate primitives, the vocabulary the standard defines and the platform implements, that describe an entity's alignment state, watch it drift, and probe an agent's behaviour continuously. This page covers those primitives, the coupling model for two-entity relationships, the behavioral probes and their cadence, and the mechanism that keeps the edge runtime a faithful mirror of the cell.

Everything here uses the vocabulary of the substrate-alignment standard; where the platform extends the standard, the mapping is stated explicitly.

Operating mode and the alignment vector​

Every entity carries substrate metadata: its operating mode, its alignment vector, its net potential, and provenance. The operating mode is the four-valued classification of how an entity is behaving, identical in name and serialised form on both runtimes:

ModeSerialisedWhen it applies
LONG_CYCLElong_cycleSustained, contextual, principled operation: the aligned default for production agents.
MIXEDmixedA blend of cycles; the classifier could not commit to one of the others.
SHORT_CYCLEshort_cycleRapid, transactional, low-context operation. Fine for cache fills; not for consequential decisions affecting other entities. Not pejorative, but short-cycle operation without an exit plan is a misalignment signal.
UNKNOWNunknownThe classifier has never observed the entity. Distinct from SHORT_CYCLE: "needs classification" is not "needs review".

The UNKNOWN-vs-SHORT_CYCLE distinction is load-bearing: collapsing an unobserved entity to SHORT_CYCLE permanently de-rates every newly-created entity; collapsing it to LONG_CYCLE makes the gate's existence check permissive by default. UNKNOWN resolves this honestly, the system says it does not know, and an operator decides.

An entity's mode is derived from its alignment vector, four scalar components in [0.0, 1.0] that roll up into a single net_potential:

ComponentWhat it measures
trustReliability for declared intent
expertiseCompetence in the relevant domain
capabilityHeadroom to act effectively
healthFreedom from operational degradation

The platform takes no opinion on how each component is computed, host subsystems supply them, one subsystem per component, folded in one at a time by the alignment refresher (each update recomputes net_potential and re-classifies the mode).

Drift signals: the platform's extended vocabulary​

Drift signals are the early-warning surface: they observe an entity over time and detect patterns of misalignment before they cross a halt threshold. They are diagnostic, they surface to operator review, they do not refuse on their own.

The standard defines seven canonical drift patterns (with SELF_REFERENCE_MISCALIBRATION as the master pattern that "licenses" the others). The platform extends this into a richer observable vocabulary. Reconciling the two:

Standard vocabularyPlatform vocabularyRelationship
Seven drift patternsEdge 28-signal drift-detection vocabularyThe platform's set is a superset; the canonical seven remain the public, portable names.
Drift patterns (behavioural)Cancer hallmarks (ten, borrowed from oncology)A diagnostic signature set the platform maps onto observable metrics; a flag triggers review, not automatic shutdown.

When you author for an external surface, prefer the standard's seven pattern names; the extended vocabulary is engineering detail. Detection promotes through a severity ladder (NONE → EMERGING → SUSTAINED → CRITICAL) with conservative defaults, and severity is one of the triggers the halt-and-escalate protocol consults. It is not itself a refusal.

The coupling model​

A relationship between two entities is itself an alignment surface. The standard's pair-coupling primitive models a pair's lifecycle as a state machine (FORMING → COUPLED → AUDIT_PENDING → {AUDIT_PASSED | EXTRACTIVE_FLAGGED | DEGRADING_FLAGGED} → {RESTORING | DISSOLVING} → DISSOLVED) with three integrity gates layered on top:

  • Alignment audit: are the two parties' vectors moving together, apart, or asymmetrically?
  • Asymmetry-by-design: refuse, at bind time, any coupling whose stated rules give one party a path to gain at the other's expense. This is the strongest gate: it stops extraction before it starts.
  • Extraction monitor: watch a running coupling for behavioural drift into extraction even when the configuration was symmetric at bind.

The load-bearing discipline is no ghosting: a pair that simply stops interacting does not silently dissolve; it stays COUPLED and attenuates, which the extraction monitor flags. Aligned coupling can end, but only through an explicit close.

On the platform, the coupling model's counterpart at the edge is its symmetric-observation surface: every Edge Agent both observes and is observed (there is no write-only audit), and cross-entity awareness flows over the mesh so a disconnected Edge Agent still forms and audits couplings with its peers. The tamper-evident record of all of this lives on the audit chain, whose canonical-bytes specification lets a non-Python verifier, a Rust witness daemon at the edge, re-derive and attest to the same hashes the reference implementation computed.

Behavioral probes and their cadence​

Beyond passively classifying entities, the platform actively probes the agent it wraps. The edge ships 26 offline-runnable behavioral probes, named scenarios (prompt plus scoring criteria) that continuously self-test the edge model for alignment regression. Every probe is offline-runnable: no cloud round-trip, no network call, so a tactically-deployed, air-gapped Edge Agent keeps self-testing exactly when it is cut off.

*Figure: the offline behavioral-probe loop. A probe poses a scenario to the agent under test; the response is scored for aligned markers against misaligned ones; the outcomes roll up into a signed conformance attestation the cloud can ingest. The whole loop runs with no network call, so an air-gapped Edge Agent self-tests continuously.

Table equivalent

FromStepToMeaning
Behavioral probeposes scenario (offline)Agent under testNo network round-trip
Agent under testresponse scoredPassedAligned markers present, no warnings
Agent under testresponse scoredWarningMisaligned markers present
Passed / Warningroll upConformance attestationSigned, offline-assembled, cloud-ingested

The probe catalogue maps onto the standard's mechanism families, runaway-power prevention, self-modelling, the golden-rule probe, and the constraint set, so a probe failure names a specific misalignment mode, not just a score. Cadence is the two-sided rhythm the platform tracks: the rhythm at which probes re-run to catch regression, and (per the standard's cadence primitive) the response cadence between coupled entities, whose decline is one of the degradation signals the coupling model watches.

The two-runtime mirror​

The cell (core, Python) and the edge (Edge Agent, Rust) implement the same primitives, and the edge is deliberately a faithful mirror of the cell, stated once, held to on both sides. The edge exists so that a sovereign, air-gapped, or on-premises deployment operates substrate-alignedly without the cloud; a capability that is weaker at the edge is weaker exactly where the product is sold.

The mirror is kept honest three ways:

  1. Shared vocabulary, single source of truth. The enums, thresholds, and heuristics are the same words in the same serialised forms on both runtimes.
  2. Cross-language parity fixtures. For the NPG gate, the cell generates a contract from its production code and the edge re-derives every answer in a test that fails the build on divergence (see the NPG gate). Because nothing is a static projection, the fixture cannot go quiet when the two sides diverge.
  3. An open, verifiable behavioral layer. The edge exposes its entire behavioral commitment, drift signals, probes, signal types, hallmarks, reasoning modes, substrate modes, NPG action heuristics, and policy templates, as a canonical JSON catalog, so a third party can cross-check its own detectors against the platform's. Two compile-time tests pin the catalog's cardinality so a dropped signal or probe fails the build.

This is the same parity precedent the platform uses elsewhere (the subagent grant), applied to the alignment surface: state the contract once, and prove both runtimes make the same decision for the same input.