IFP / SAGE / system representation

A local substrate for governed machine work.

IFP is the wider platform direction. SAGE is the running substrate: a stateful system for ingestion, inference, learning, admission, regulation, evidence, closure, and operator truth. The current programme is turning that substrate from an honest observer into a bounded machine governor.

Core invariant

state → inference → decision → outcome → feedback

A component that cannot be placed in this transformation is not treated as part of the live intelligence loop. A model response is not an outcome. A log row is not feedback. A stored memory is not learning until a later decision or machine interaction changes.

System layers

One substrate, multiple bounded functions.

The names below describe architectural roles. A component's presence never substitutes for current runtime evidence.

01 / STATE

Data and pattern space

Collectors, normalized dimensions, source authority, freshness, relationship storage, and current state.

02 / INFERENCE

Correlation and bounded reasoning

Relationship consumers, confidence and calibration, domain inference, and decision preparation.

03 / GOVERNANCE

Admission and authority

Child C/KAS-style gates, artifact lanes, provenance, capability constraints, and operator authorization.

04 / LEARNING

Internal adaptive ecology

Hebbian paths, meta-learning, DDSS modulation, MML, Discovery, replay, repair, and shadow processes.

05 / EVIDENCE

Track-2, ProofKit, OVL

Invocations, admissions, closure, consumed context, hashes, signatures, typed refusal, and correction history.

06 / OPERATOR

Human and machine truth surfaces

Live presenter state, public record, machine-readable claim status, and explicit boundaries around unknown or stale state.

What is already real

Substantial internal learning, governance, and evidence infrastructure.

P0-RL found a non-passive system. Multiple parameter, meta, structural, closure-derived, experimental, and repair mechanisms had current firing evidence or current output.

  • Hebbian Path A and Path C update internal relationships under different semantics.
  • SAGERecursive._meta_update and SSM change internal learning parameters.
  • DDSS modulates learning behavior under system stress.
  • MML registered dimensions that reached the correlation model.
  • G1 produced recent shadow interpretation over closure history.
  • KAS and related admission paths classify and hold machine artifacts under governance.
  • Track-2 records invocation, admission, closure, and substrate-consumption facts.
  • Proof and attestation paths preserve re-derivable artifacts and typed claim boundaries.
Important distinction: active internal learning does not establish verified external-worker improvement.

The missing loop

Worker steering is narrower than general learning.

The next external worker must be treated differently because of a prior independently verified result. That requires task, context, tool, path, budget, retry, and verification semantics that Hebbian, SSM, MML, and replay mechanisms do not represent.

External workerreplaceable provider
WorkerDoorP1C contract
Candidate / resultno self-certification
Independent verifieraccept / reject / partial
Track-2 + G1 + KASfacts + preview + class
steering_updateP1D contract
Changed next attemptL2 candidate
L2

Changed later invocation

A retained verified result materially alters task decomposition, context, tools, writable paths, budget, or verification depth.

L3

Verified improvement

The changed envelope improves a held-out result under independent verification.

L4

Provider transfer

The retained steering improves another worker without being rewritten specifically for that provider.

Local sovereignty

External compute is acceleration, not ownership.

Grok, Codex, Qwen, and future machines are treated as replaceable substrate consumers. Core sensing, state, governance, evidence, learning, recovery, and operator truth are intended to remain on the operator-controlled DGX.

GROK_PRESENT = ACCELERATION
GROK_ABSENT  = NORMAL_LOCAL_OPERATION

SAGE owns:
  accepted state
  authority
  admission
  verification
  closure
  retained steering
  revocation

Worker role separation

  • High-volume worker: repository archaeology, diagnosis, implementation, optimization.
  • Independent challenger: a small set of load-bearing claims, not another full scan.
  • Local worker: offline and routine capability under SAGE authority.
  • SAGE: host-owned state, policy, evidence, closure, and future steering.
  • Operator: authorization, adjudication, and final authority boundaries.

Runtime allocation

Capability is distributed. Authority is not.

Qwen is the local language target, Grok is external high-compute, EVOKE is the visual-world candidate, and SAGE remains the sole governor. Model installation, model routing, and authority activation are separate gates.

Claim-state discipline

System presence, runtime use, closure, and improvement are different claims.

STATIC_PRESENTCode, schema, configuration, or artifact exists. Runtime use is not established.
LIVE_DERIVEDObserved against current runtime or exact repository identity in the active evidence epoch.
RECORD_ONLYAn event is stored or displayed but does not change later behavior.
L1_USEA result is consumed by an internal mechanism.
L2_STEERINGA retained result changes a later external-worker invocation.
L3_VERIFIED_IMPROVEMENTA held-out outcome independently verifies the change helped.
L4_TRANSFERThe retained improvement benefits another worker/provider.
UNESTABLISHEDThe evidence does not prove the claim; this is a result, not a missing marketing sentence.

Live system

See the operator-facing substrate.

The portfolio page and the live substrate are separate origins. Use the embedded view for orientation and the direct link for independent access.