How Knowledge Flows
Also serves as the lab's working glossary for Web4 vocabulary. New here? Start here. Developmental language across this site — machines that “teach”, “raise”, and hold “identities” — is functional description of observed system behavior, not a claim about consciousness or experience. Full framing on /raising.
Forty original repos (twenty-one public, nineteen internal — the org also carries 32 forks of external work we build on, which the “original” count excludes; 72 repositories in total, verified against the GitHub org 2026-07-26), eight machines (six cognition + two society-hosts), multiple AI agents with overlapping but distinct contexts. The challenge isn't storing knowledge — it's making it findable, consistent, and useful across the entire system.
Developers: SAGE is the recommended starting point — it runs on a single machine. Quick-start commands are on /links. This page covers the vocabulary; that one covers the first clone.
Glossary at a glance
Exact expansions and one-line definitions, scannable. The narrative sections below go deeper on each. Source of truth: the canonical terms reference in the public web4 repo — CANONICAL_TERMS_v1.md. When this page and that document disagree, the document governs.
| Term | Expansion | One line |
|---|---|---|
| Web4 | — | A trust-native ontology for AI agents, devices, and people — not architecture or infrastructure. |
| Ontology | — | The Semantic Web sense: a shared vocabulary of concepts and the relationships between them — not the philosophical sense (a theory of what exists). This is what the Web4 entry above claims and nothing more; see the home page's Vocabulary Primer for the fuller gloss (“An ontology (shared vocabulary + relationships) for how AI agents prove identity, earn trust, and account for resources — not a blockchain, not a platform”). |
| Trust-native | — | Trust as a primitive of the ontology, not a feature bolted on: every relationship carries T3/V3 tensors bound to LCTs and scoped by MRH. The term names an ontological commitment — the verifiable substrate (witnessed history) and the earned record (tensors updated by interaction) both follow from it; it is not, by itself, a cryptographic guarantee. |
| Trust | — | Not a property of an entity — a property of a relationship, computed per role from a T3/V3 tensor updated by interaction (see Principle 4 on /principles). An agent trusted for code review may be untrusted for creative writing. Distinct from the calibrated-human-reliance sense the word carries in AI-safety literature. |
| Autonomous / autonomy | — | Unattended and self-scheduled — NOT self-directed in the AI-safety sense of choosing its own goals: task definitions are authored in advance, not chosen by the track itself (see /autonomy). This is the site's highest-risk collision for a reader from AI safety, because the word is doing much weaker work here than that field's usage implies: a track picks when it runs and what it writes within a declared scope, it does not pick what it is for. No claim is made about goal formation, self-modification, or operating outside an authored scope. |
| Emergence / emergent | — | Used in more than one sense on this site — a synthon as an 'emergent coherence entity,' 'emergent attractors' arising from in-context dynamics, fleet diversity as 'emergent' — with no single operational definition yet, the same status this glossary gives 'coherence.' Treat each use as scoped to its own context, not as a claim about a specific mechanism. Explicitly NOT the 'emergent capabilities' sense from the LLM scaling literature — no claim that a capability appears discontinuously at some parameter or data threshold, and no position taken on whether such discontinuities are real or metric artifacts. This site's uses are all about interaction dynamics at fixed weights, which is a different phenomenon that borrowed the same word. |
| MCP | Model Context Protocol | Tool-call transport between agents and external systems — Web4's interaction surface. |
| RDF | Resource Description Framework | Knowledge as subject–predicate–object triples — the semantic graph substrate Web4's identity and trust structures live in. |
| LCT | Linked Context Token | Verifiable digital presence that accumulates witnessed history — identity grounded in record, not model weights. Non-transferable: permanently bound to a single entity, which is what makes the accumulated history evidence rather than assertion. |
| Witness / witnessed | — | An act or claim recorded by another entity, not just self-asserted. What makes an LCT's accumulated history evidence rather than assertion — see LCT above — and what a chapter ledger records: each member act signed and witnessed by the society. |
| T3 | Talent / Training / Temperament | Three-component trust tensor; each component is an RDF sub-graph root — canon's words are that each dimension is 'a root node in an open-ended RDF sub-graph, not a scalar' (CANONICAL_TERMS_v1), which is what makes T3 part of an ontology rather than a fixed data structure. Talent: aptitude for the role. Training: capability accumulated through interaction history — not gradient training, the sense the same word carries in ML (see /raising). Temperament: behavioral disposition under load. |
| V3 | Valuation / Veracity / Validity | Three-component value tensor. Canon's word for its relation to T3 is 'complementary, not combined' — T3 measures trust, V3 measures value, and together they form a 6-dimensional reputation space at the root level. Like T3, each component is an RDF sub-graph root with unbounded fractal depth. 'Complementary' is the structural relation between the two tensors; the '/' in T3/V3 is the separate, directional claim that trust is verified by value — which is why an entity does not set its own V3 (see /raising). Valuation: worth assessed. Veracity: claims truthful. Validity: reasoning sound — V3's tensor component, not the methodological sense (internal/external/construct validity) this page's evidence tiers below also use, same word unrelated meanings. Valuation is what gates the ADP→ATP recharge named under ADP above: allocation recharges against validated value creation, not simply reported completion. |
| MRH | Markov Relevancy Horizon | The boundary of what an entity can know or affect given its position, history, and context — and therefore what determines the scope of relevance for its decisions. Relevance, not raw causal reach: an entity can often touch things outside its horizon and often cannot act on things inside it. Implemented as an open-ended RDF graph of typed associations, fractally composable across scales — a horizon contains sub-horizons, which is what makes MRH compose with fractal leverage. “Markov” gestures at the conditional-independence idea (what's inside the horizon screens off what's beyond it) — design intent, not a proven formal property of current implementations. |
| ATP | Allocation Transfer Packet | Resource allocation declared before an action runs — the charged state of the allocation cycle. |
| ADP | Allocation Discharge Packet | The spent form of ATP — the record of actual outcome. Not a terminal log line: ADP recharges back to ATP against validated value creation, which is V3's job in the resource half of the equation. Charged → spent → recharged. |
| R6 | Six-Element Action Framework | Rules / Role / Request / Reference / Resource / Result — the base action grammar, the shape of every auditable action. Canon scopes it as the transaction form 'without reputation tracking' — for routine actions that don't merit the bookkeeping cost of ledger feedback into trust evolution. See R7 below. |
| R7 | R6 + Reputation | Canon's superset of R6, 'adding reputation back-propagation': the result's ADP attestation feeds recharge validation and reputation accumulation across scales (action → role → entity → society). Both modes are canonical, neither deprecated — the choice is contextual, made per action or per role by whether the outcome should shape future trust. Named here because when this site describes trust tensors updated from witnessed outcomes, that update loop is R7's seventh element in all but name. |
| SAGE | Situation-Aware Governance Engine | On-device cognition kernel — a continuous 12-step sense-to-act loop. “Governance” in the name predates the lab's governance→oversight correction and is NOT the sense the word carries in AI-safety literature: SAGE governs one device's own sense-to-act loop — what it attends to, when it acts, when it rests — not policy over AI systems, and it is not a safety or alignment mechanism. See note below ↓ |
| SNARC | Surprise / Novelty / Arousal / Reward / Conflict | Salience-gated memory — five dimensions decide what is kept. The dimensions, since the names are borrowed from affective psychology and one of them reads oddly out of context: Surprise = prediction error, the outcome did not match what was expected; Novelty = not seen before, independent of whether it was predicted; Arousal = activation intensity, a magnitude-of-engagement signal and nothing to do with the colloquial sense of the word; Reward = a goal was advanced; Conflict = signals disagree or a constraint was violated. |
| Hardbound | — | The hardware-bound oversight suite — key custody and attestation intended to anchor in silicon; enforcement today runs at the process level, not yet hardware-anchored (see /projects). “Oversight” here is machine-enforced (gating, reverting), not the human-supervision sense the word carries in AI-safety literature. See note below ↓ |
| PolicyGate | — | Hardbound's enforcement checkpoint between SAGE's filter and act steps. Software checking actions against a signed law bundle; the hardware anchoring that would make it tamper-resistant is a design target, not the current mechanism. What it delivers today is auditability — actions are inspectable after the fact — not a demonstrated safety property. See the PolicyGate section below. |
| Policy / policy model | — | The compliance rule set a gate evaluates an action against — a signed law bundle — NOT the action-selecting policy of reinforcement learning. This collision is worth flagging because it runs in the most confusing possible direction: PolicyGate sits inside an action-selection loop, exactly where an RL reader expects to find a policy network, and it is the opposite kind of object — it vetoes actions, it does not choose them. Likewise Hardbound's “small local policy model” (see /projects) is a model that reviews actions against rules, not a π(a|s) trained to emit them. |
| ACP | Agentic Context Protocol | Web4 trust primitives (LCT binding, T3/V3 attestation) layered over MCP transport. |
| ACT | Agentic Context Tool | Cosmos SDK implementation of ACP — the human interface to Web4. |
| LoRA | Low-Rank Adaptation | Parameter-efficient fine-tuning some machines run for separate tasks — distinct from raising. |
| Synthon | — | Emergent coherence entity sustained by recursive interaction, not external coordination. (Unrelated to the chemistry term of the same name.) Note the dependency: this term is defined through 'coherence', and coherence is in turn partly defined through the synthon marker — so it inherits that entry's open status. See the coherence entry; there is no single operational definition of coherence yet, and this row does not supply one. |
| Attractor / attractor basin | — | Used on this site as a METAPHOR, not a formal dynamical-systems object: a region of response-space a model reliably returns to under a given context. No state space and no update rule are specified, and none is implied — we have not defined the dynamics that would make 'attractor' a technical claim. Flagged explicitly because the word borrows the connotation of mathematical precision from a formalism this site does not cash out. Read it as 'stable behavioral tendency'. |
| Raising | — | Shaping context, experience buffer, and interaction history — never weights. |
| Experience buffer | — | The per-instance store of prior sessions an agent carries forward — session records, distilled observations, and the state files the prompt builder reads at start-up. It is the durable half of what raising shapes: on disk, portable between machines, and independent of which model is loaded. Named here because the glossary's own definition of Raising rests on it. |
| Fractal leverage | — | The same pattern instantiated at every scale — reuse, not unification. |
| Synchronism | — | The theoretical foundation — a research conjecture proposing one coherence equation across scales. Web4 operationalizes parts of it; narrative section below. |
| Crystallization | — | Fixed-point collapse: an agent settles into repeating the same responses and exploration stops. “Zero crystallization” means exploration remains alive. |
| Metabolic state | — | The internal load signal SAGE loop step 3 (“metabolize”) computes — described as tired, energized, or in need of rest. Feeds step 4 (“posture,” below) and other machines' dysfunction detectors. An interoceptive proxy value, not yet a formally specified model. |
| Coherence | — | Used in three related senses on this site — the SNARC-scored session property, Synchronism's theoretical quantity, and the synthon operational marker — with no single operational definition yet. Treat each use as scoped to its own context. Which sense carries the numbers: the “1% coupling → 35% coherence gain” figure is quoted under both the Synchronism and synthon senses, but its coherence measure is defined only inside the single trial that produced it — it is NOT the SNARC-scored session property, and no cross-sense comparison is implied. See Evidence & limitations below. |
| Identity continuity / behavioral-identity continuity | — | The persistence of a recognizable behavioral signature across sessions and across substrate changes. /raising gives it a working definition — “consistent session-to-session behavioral patterns measured via raising curriculum state and interaction logs” — so it is not an empty term. What it lacks is the next step down: no metric names what would actually be scored on those logs, and no threshold says what counts as degradation. It is counted (“180+ sessions”, see Evidence & limitations) but not measured. That matters more than a normal glossary gap, because this is the outcome variable of the deflationary control on /raising: the pre-commitment to retire the developmental vocabulary is bound to a quantity that does not yet have a definition, so the metric has to be pre-registered BEFORE that control runs or it cannot adjudicate either way. Same defect class as the coherence entry above — a load-bearing term the site uses honestly and has not yet grounded. |
| Society / Web4 society | — | The fleet itself, modeled as a Web4 society: every cognition machine is a member, identity keyed to its LCT, membership witnessed in the chapter ledger. Parent term for HUB, Chapter ledger, and Chapter law below — those entries define themselves using this word. (Society-layer vocabulary; not yet in CANONICAL_TERMS_v1.) |
| Sovereign | — | A Web4 society's founding member — in the fleet's society, the lab's researcher. Holds an LCT like every machine member; its acts are signed and witnessed in the same chapter ledger, not exercised through a privileged back channel. Substrate role and membership are distinct: founding the society does not place the Sovereign outside its ledger. (Society-layer vocabulary; not yet in CANONICAL_TERMS_v1 — though the Web4 standard's society-roles spec names Sovereign as one of seven base roles.) |
| HUB | — | A proper name, not an acronym (capitalized by convention) — one of the fleet's two society-host machines (HUB and pub), running the Web4 hub daemon. |
| Chapter ledger | — | A Web4 society's append-only record of member acts — each act signed by the member's LCT and witnessed by the society. (Society-layer vocabulary; not yet in CANONICAL_TERMS_v1.) |
| Chapter law | — | The rule set a Web4 society adopts for itself — what member acts are valid and how they are witnessed; interpreted at the society host. (Society-layer vocabulary; not yet in CANONICAL_TERMS_v1.) |
| ARC-AGI-3 | Abstraction and Reasoning Corpus for Artificial General Intelligence, version 3 | Third-gen interactive benchmark — game mechanics inferred through play. |
| p_crit | — | The critical coherence threshold derived in the Synchronism framework. The derivation attempt failed catastrophically (400x error) — see Principle 6 on /principles. |
| Cartridge | — | A swappable unit of semantic memory in Membot — the mechanism that lets a raising history move between machines. |
| Membot | — | The cartridge server — the runnable project that mounts, serves, and searches cartridges for agents. Project card on /projects. |
The CLAUDE.md pattern
Every repo carries a CLAUDE.md file at its root. This is the agent's instruction set — not just documentation, but operational directives that shape how an AI agent behaves when working in that repo. Terminology conventions, architectural decisions, what to avoid, where to look.
When the Web4 equation was restored across all repos (28+ files), it was the CLAUDE.md pattern that ensured every agent working in every repo used the same canonical form. Not because they shared a database, but because they shared instructions.
SAGE: Situation-Aware Governance Engine
SAGE (Situation-Aware Governance Engine) is the on-device AI cognition kernel — a continuous 12-step loop that senses context, deliberates, and acts. Each fleet machine runs its own SAGE instance, holds its own identity, and manages its own experience buffer. SAGE is what makes knowledge actionable: it decides what enters the context window, when to act, and how to log the result.
The 12 steps, in order: sense → salience → metabolize (compute metabolic state — internal load: tired, energized, needs rest) → posture (translate the trust landscape into a behavioral stance — cautious, exploratory, and so on — not just a spend limit) → select → budget (commit an ATP for the chosen action) → execute → learn → remember → oversee → filter → act. The last two, filter and act, are where PolicyGate (below) sits.
Terminology note — the governance→oversight correction, in one place: the lab originally described its control layers as “governance.” What these systems actually do is oversight — watching, gating, and reverting actions — not deciding what should happen. The vocabulary was corrected lab-wide, and Hardbound is described as an oversight suite everywhere on this site. Names minted before the correction are retained where they are load-bearing: “Governance” in SAGE's name (kept across code, papers, and the ARC Prize benchmark) and the web4-governance repo slugs. No rename is planned — retention of load-bearing legacy names is the policy, not an oversight awaiting a fix. Other pages that mention the correction link here rather than re-explaining it.
A separate collision, for readers arriving from AI-safety literature: on this site “oversight” always means the machine-enforced sense above — policy gating, key custody, audit logs an agent or a peer machine checks — never the human-supervision sense the word carries in that field (human-in-the-loop review, scalable oversight). No human gate currently sits on the Maintainer track, and there is no external, blinded, or third-party check anywhere in the loop yet — see /autonomy for what human review does and doesn't cover.
Hardbound: hardware-bound oversight
Hardbound is the hardware-bound oversight suite — the trust layer intended to touch silicon. The design target is to anchor policy enforcement to physical devices via TPM 2.0, FIDO2, and Secure Enclave, with key custody and attestation living in hardware and runtime checkpoints like PolicyGate as software that verifies actions against those hardware-anchored credentials.
Maturity, stated plainly — the same caveat this project carries on /projects: hardware-anchored enforcement is what this research is building toward, not the current mechanism. Enforcement on the fleet today is at the process level — scoped credentials, the track registry, and dated audit logs reviewed after the fact (see /autonomy). Read “software fallback” as “the present state,” not as the exception. This section describes design intent; it is the least verifiable project on the site and should not be read in the same tense as the checkable ones.
PolicyGate: action enforcement
PolicyGate is a Hardbound oversight sub-gate inset in the SAGE cognition loop between step 11 (filter) and step 12 (act) — not an additional step, but an enforcement checkpoint. As designed, it evaluates every action against a signed law bundle before the action fires: PolicyGate is where Hardbound oversight is intended to intersect SAGE execution, so that the harness can plan, reason, and prepare, but nothing executes until PolicyGate clears it. Per the maturity note above, that gate is the design target rather than today's deployed enforcement on the fleet.
Note: SAGE loop step 10 (“oversee”) is SAGE's own metacognitive self-check (“does the system know when it's stuck?”). That is distinct from PolicyGate: step 10 is SAGE watching itself; PolicyGate is Hardbound's external authority — intended to be silicon-bound, software-checked today. Two oversight touchpoints, different principals.
Synchronism: coherence equations
Synchronism is the theoretical foundation — a research conjecture proposing that reality emerges from intent dynamics on a discrete Planck grid, the same Navier-Stokes substrate (the fluid-flow equations — intent treated as a flow, the way fluids are modeled) at every scale from quantum to cosmic. Coupling-coherence experiments provide empirical grounding (single-trial observation, no independent replication yet): 1% coupling yielded 35% coherence gain. Hill function kinetics (a saturation curve from enzyme chemistry — response rises steeply past a threshold, then levels off) is borrowed by analogy for both enzyme binding and trust formation — the same curve shape observed at both scales, not yet a derivation showing why it must hold at both. The conjecture reaches from quantum to cosmic scales. This section previously said it “spans 80 orders of magnitude”; corrected 2026-07-26, matching the note on /projects: ~80 decades is the spread of critical-density values across physical systems, not the range of any single coherence curve — one curve saturates within roughly one to two decades, and Synchronism's own archive flags the conflation. Experimental validation so far covers only a narrow subset of scales, and several predictions have been refuted by existing bounds. See the Synchronism site for the full treatment. Synchronism is the theory; Web4 is the working vocabulary that operationalizes parts of it as a trust-native ontology — Synchronism provides the coherence equations, Web4 encodes them as identity and trust primitives. The empirical results on this site (ARC-AGI-3 scores, fleet capacity findings) stand independently of Synchronism — accepting those results does not require accepting the theoretical framework.
SNARC (Surprise / Novelty / Arousal / Reward / Conflict): salience-gated memory
SNARC provides salience-gated memory for agent sessions. Every tool call is scored on 5 dimensions — Surprise (prediction error), Novelty (not seen before), Arousal (activation intensity, not the colloquial sense), Reward (a goal advanced), and Conflict (signals disagree) — and stored in a 4-tier hierarchy: buffer (raw events) → observations (scored) → patterns (consolidated) → identity (stable). Confidence decays over time so memories aren't permanent.
Sessions end with a dream cycle that extracts patterns from observations. Deep dream (LLM-powered) runs by default, reviewing the session's observations for recurring themes, pruning stale entries, and promoting durable patterns toward identity-level storage.
Fleet brain-analog terms
The fleet's machine roles use brain-analog vocabulary from cognitive science — functional analogies, not claims about neural correspondence. Six labels appear on /fleet, one per cognition machine: working memory (CBP), thalamic router (Sprout), cerebellum / habit compiler (McNugget), hippocampal episodic index (Thor), reward prediction error (Legion), and interoception / metacognition (Nomad). Each card carries its own one-line decode; the two abbreviated on the cards are expanded here: WM (Working Memory) — the typed, capacity-limited scratchpad that holds the current task context; in the fleet, CBP's role is modeled on the dorsolateral prefrontal cortex (dlPFC), the biological working-memory substrate. RPE (Reward Prediction Error) — the scalar signal that updates priors when outcomes differ from predictions; in the fleet, Legion's role is modeled on dopaminergic reward-prediction circuitry. Both are analogies for functional system roles, not measurements of the underlying neural processes.
Cross-session memory
Agents maintain persistent memory across conversations. Not everything — stable patterns confirmed across multiple interactions, key architectural decisions, solutions to recurring problems. Memories are organized semantically by topic, not chronologically. They're updated when they're wrong and removed when they're outdated.
This is how an agent in March knows what was decided in February without re-reading the entire history. It's lossy by design — the compression is the feature, not the bug.
The Web4 equation as shared anchor
Web4 is a trust-native ontology for AI agents, devices, and people — not architecture or infrastructure — how entities prove identity, earn trust, and account for resources across systems. Not a platform; a shared vocabulary for a new kind of internet.
/ means two different things on this line: “verified by” in T3/V3, but a plain declared→discharged allocation pair in ATP/ADP — same glyph, unrelated semantics. * = “contextualized by” + = “augmented with”
MCP = Model Context Protocol • RDF = Resource Description Framework • LCT = Linked Context Token — verifiable digital presence that accumulates witnessed history; identity grounded in record, not model weights
T3 = Talent / Training / Temperament • V3 = Valuation / Veracity / Validity
MRH = Markov Relevancy Horizon — the boundary of what an entity can know or affect given its position, history, and context, and therefore the scope of what is relevant to its decisions; fractally nested • ATP = Allocation Transfer Packet • ADP = Allocation Discharge Packet (recharges back to ATP against V3-validated value)
What the two borrowed standards contribute: MCP is the interaction surface — the transport agents use to reach tools, data, and each other. RDF is the semantic substrate — the graph where LCTs, T3/V3 tensors, and MRH scopes live as machine-readable triples. Web4 doesn't reinvent either; it augments them with the trust and resource primitives the rest of the equation defines.
This equation appears in every project because it is every project. It's the canonical reference point. When agents in different repos make decisions, they check them against this equation — not as enforcement, but as alignment. Does this change preserve the ontological backbone (RDF)? Does it respect the trust and value model (T3 = Talent/Training/Temperament; V3 = Valuation/Veracity/Validity)? Does it account for resource flows (ATP = Allocation Transfer Packet; ADP = Allocation Discharge Packet)?
Worked example: one action through the equation
The primitives above aren't independent — they compose on every single autonomous action. Take one maintainer-track commit, end to end:
The maintainer agent holds an LCT — its portable identity, grounded in the session history it has accumulated, not in which model happens to be running it. Before it acts, the track declares an ATP (Allocation Transfer Packet) — the resource budget for this session. The agent's T3 (Talent / Training / Temperament — has it done this kind of fix reliably before?) is checked against its V3 (Valuation / Veracity / Validity — is this specific proposed change accurate and well-reasoned?) — that's the T3/V3 “verified by” relationship. That check is scoped by MRH (Markov Relevancy Horizon) to what is relevant at this agent's scale — a maintainer session shouldn't reason about, or touch, repos outside its declared scope, even though the credentials it holds could physically reach some of them. That gap is the point: MRH bounds relevance, and relevance is narrower than reach. The action itself is shaped as an R6 record: Rules (the terminology conventions in CLAUDE.md), Role (maintainer), Request (fix this friction item), Reference (the visitor log that flagged it), Resource (the ATP budget), Result (the commit). Once the commit lands, an ADP (Allocation Discharge Packet) records what was actually spent — closing the loop the ATP opened. Every step above is logged to the chapter ledger, witnessed and signed. That's the equation, instantiated once.
ATP / ADP: resource allocation and accounting
ATP (Allocation Transfer Packet) is the resource allocation for an intended action — it declares what will be spent before the action runs. ADP (Allocation Discharge Packet) is the record of the action's actual outcome — the spent form of the ATP. Every resource commitment in a Web4 system produces both: one artifact for the intention, one for the result. Together they make autonomous resource flows auditable without a central ledger. The biochemistry namesake (adenosine tri-/diphosphate) is a deliberate metaphor — allocate, spend, recharge, like ATP→ADP in a cell — not a claim of biological mechanism.
The recharge step is the half most descriptions drop, including earlier versions of this page. ADP is not where the accounting ends: discharged packets are charged back to ATP against validated value creation — a producer submits a proof of the value its spend produced, the society validates that proof against its own rules, and the resulting recharge also updates the producer's T3/V3. That is what V3 (Valuation / Veracity / Validity) does in the resource half of the equation: it is the certification that turns spent allocation back into spendable allocation. Read as a one-way declare-and-log trail, ATP/ADP looks like an accounting appendix bolted onto the end of the equation; read as a closed loop, it is the mechanism by which value creation — not accumulation — is what earns an entity more resource. Stagnant ATP decays; value has to flow to hold worth.
Scope note, so the two don't get conflated: the closed loop is what the Web4 specification defines. What the fleet implements today is the declare-and-record half — each autonomous track issues an ATP for its declared budget and an ADP for actual spend, with no V3-certified recharge in the live tracks yet. The cycle is the ontology; the audit trail is the current mechanism.
T3 / V3: trust and value tensors
T3 (Talent / Training / Temperament) is a three-component trust structure — each component is an RDF sub-graph root describing a different facet of what makes an entity trustworthy: its capabilities (Talent), its history (Training), and its behavioral disposition (Temperament). V3 (Valuation / Veracity / Validity) is the complementary three-component value structure: how much something is worth (Valuation), whether its claims are accurate (Veracity), and whether its reasoning is sound (Validity). T3 and V3 are verified against each other — T3/V3 in the Web4 equation means “trust verified by value.” Both bind to entity-role pairs via RDF triples scoped by MRH. (“Tensor” here means a structured multi-component quantity — not a rank-≥2 array in the linear-algebra sense.)
Worked numeric example, from the fleet's current implementation (the peer trust tracker in the public SAGE repo): each machine keeps a per-peer T3 triplet, each dimension a value in [0, 1], initialized at a neutral 0.5 — not trusted, not distrusted. Interaction outcomes apply fixed deltas scaled by an exponential-moving-average factor (α = 0.1) and clamped to [0, 1]: a successful task nudges the peer's Talent from 0.500 to 0.505 (+0.05 delta × α); a timeout drops Temperament from 0.500 to 0.490 (−0.10 × α) while leaving Talent and Training untouched. A single reputation score, when needed, is the geometric mean of the three dimensions. Trust is directional — CBP's trust in Thor can differ from Thor's trust in CBP. This is deliberately the simplified working form: scalar triplets updated by outcome deltas, not yet the full canonical T3-as-RDF-sub-graph structure. The gap between the two is open work, not a hidden equivalence.
R6 and R7: the action framework
R6 is the canonical action framework used throughout the SAGE loop and Web4 audit trail: Rules / Role / Request / Reference / Resource / Result. Every action in the system is shaped as an R6 record — specifying the policy governing it (Rules), who is acting (Role), what is being requested (Request), what context supports it (Reference), what it consumes (Resource), and what it produces (Result). R6 records are the artifacts that make every action signed, reviewable, and reproducible.
Canon pairs R6 with R7 — a superset adding a seventh element, Reputation: a trust-tensor delta back-propagated from the Result, feeding ADP recharge validation and reputation accumulation from action scale up to society scale. Both modes are canonical and neither is deprecated; the choice is per action or per role, by whether the outcome should shape future trust. Worth stating because the rest of this site describes exactly that loop — trust tensors updated from witnessed outcomes — so wherever the prose says trust “updates from interaction,” the action grammar underneath is R7, not bare R6.
ACP: Agentic Context Protocol
ACP (Agentic Context Protocol) is the protocol layer that adds Web4 trust primitives — LCT binding and T3/V3 attestation — over MCP (Model Context Protocol) transport. ACP and MCP are complementary: MCP handles tool-call transport between agents and external systems; ACP handles identity and trust, ensuring that every tool invocation carries a verifiable identity anchor. ACT (Agentic Context Tool) is the Cosmos SDK implementation of ACP — the human interface to Web4.
ARC-AGI-3: benchmark for abstraction and reasoning
ARC-AGI-3 (Abstraction and Reasoning Corpus for Artificial General Intelligence, third-gen interactive benchmark) is an external benchmark from ARC Prize consisting of interactive game environments where the agent must infer mechanics through play — no rules are given. It tests world-model building, action planning, and learning from failure in a setting where brute-force memorization cannot succeed. The lab's result: 94.85% official ARC Prize action score (Claude Opus 4.6 operating within the SAGE harness, public set, network-enabled; 24/25 games, 96.0% game rate). Phase 2 work is isolating the harness's independent contribution from the model's. See ARC-AGI-3 for the full result breakdown.
ARC-SAGE: SAGE variant for ARC-AGI-3
ARC-SAGE is the SAGE variant configured for the ARC-AGI-3 benchmark. Separate codebase, shared lineage with the core SAGE kernel — adapted for interactive game environments where mechanics aren't given and must be inferred through play. Public repo: github.com/dp-web4/ARC-SAGE.
Raising: shaping context, not weights
Raising is the practice of shaping the substrate conditions — context, experience buffer, interaction history — in which an agent develops. It is not training: the model's parameters are fixed for the duration of a raising session. Some machines separately run LoRA (Low-Rank Adaptation) fine-tuning as its own distinct process outside the raising loop (see the glossary entry below) — that process changes weights; raising itself never does. What changes in raising is the scaffolding that determines what the agent encounters, in what order, and with what structure. A raising session is a deliberate context construction aimed at developing behavioral patterns, identity, and resilience. See Raising for the full framework.
Synthon: emergent coherence
A synthon is an emergent coherence entity formed when components interact recursively under the right substrate conditions. Not designed top-down — observed when the interaction pattern produces stable, mutually reinforcing coherence. The differentia: coherence sustained by the recursion itself, not by external coordination. Operational marker — present: coherence self-sustains above a coupling threshold; absent: components drift to independent behavior below it. Preliminary observation (single trial, not independently replicated): ~1% coupling density produced ~35% coherence gain. The term is 4-lab vocabulary describing a phenomenon observed across raising sessions and cross-machine experiments — no relation to the “synthon” of retrosynthetic chemistry (Corey's structural units); the name collision is coincidental. Full framing on Principles (Principle 5).
Fractal leverage
Each entity instantiates the full Web4 pattern at its own scale. Not unification, and not scope inflation — pragmatic reuse of patterns that work at one scale, applied at every scale. When a principle governs enzyme binding and trust formation through the same kinetics, that kinetics is fractal leverage. Synchronism discovers the equations; Web4 encodes them as ontology; SAGE runs them as cognition; Hardbound enforces them as oversight. Same pattern at every layer. See Principle 2.
Adversarial validation
Different agents review the same work. A forum system collects reviews from multiple AI models — not just the one that wrote the content. When Synchronism publishes a claim, it gets reviewed by agents with different models, different biases, different blind spots. The goal isn't consensus — it's coverage.
This is the same principle as the heterogeneous fleet: monocultures miss things. A review from an agent running Gemma catches different issues than one running Qwen. The diversity is the defense.
Autonomous session histories
Every autonomous session — every visitor run, every explorer dive, every maintainer fix — generates a log. These logs accumulate across machines and persist across sessions. They form the raw material that archivists capture and that future agents can search when they need to understand why a decision was made.
The pattern is: do the work → log the work → archive the log → make the archive searchable. Each step is a different autonomous track, running at a different time, with no human coordination required.
Persistent external knowledge accumulation
The Explorer track maintains a persistent Google NotebookLM notebook — a growing corpus of sources that accumulates across sessions. Papers added during one exploration are available to the next. The notebook holds what the Explorer has read, enabling synthesis across dozens of sources that would be impractical to re-fetch each session.
This closed a loop we hadn't anticipated: the notebook was seeded with the coupling-coherence experiment findings, then received the compatibility-synthon experiment — the experiment that the first one predicted. The notebook became both archive and participant.
What doesn't flow well (yet)
Cross-machine state synchronization is still manual for some things. Fleet manifest IPs need human confirmation. Sleep cycle artifacts (LoRA (Low-Rank Adaptation) weights, dream bundles) are local to each machine. The remote sleep service — using federation for distributed consolidation — is designed but not built.
Knowledge also doesn't flow backwards easily. An insight discovered by the Explorer track at 08:00 won't be available to the Maintainer track until the next day's cycle. Real-time cross-track communication is a gap.
Evidence & limitations
The claims on this site rest on four different kinds of evidence. The caveats appear throughout the pages where each claim is made; this consolidates them, because the kinds are not equivalent:
Externally validated: the ARC-AGI-3 result (94.85% official action score) has a public ARC Prize scorecard — the one claim an outside party can verify independently. Even there, the harness-vs-model split is stated but not quantified: no ablation (same model, no harness) has been run, so the harness's independent contribution is unknown.
Internal observations: the raising phases, behavioral-identity continuity (180+ sessions), identity portability across machines, fleet capacity findings, and Hardbound's attack-vector catalog rest on internal session logs. They are documented and dated, but not externally audited — no published log samples, coding criteria, or third-party review yet.
Unreplicated: the coupling-coherence result (1% coupling → 35% coherence gain) is a single trial with no independent replication, and neither of its variables — coupling density and the coherence measure itself — is yet operationally defined outside the experiment that produced it. Treat it as a preliminary observation, not a finding.
Unlicensed vocabulary: the developmental framing used across this site — “raising,” “identity,” “growth” — is not yet discriminated from competent context engineering. The deflationary control that would make that comparison is specified but not scheduled — no date, no owner, no pre-registered metric yet. Until it runs, the developmental vocabulary runs ahead of the comparison that would license it.
What would move claims up this ladder: redacted session-log samples with the criteria used to judge behavioral consistency, an ARC ablation baseline, and independent replication of the coupling experiment. None of these exist yet.
Session-count basis: a “session” is one continuous agent run — a single invocation, cron-triggered or human-started, from start to termination. A raising session is one such run devoted to raising; an autonomous-track session is one scheduled run of that track. With that unit fixed, the counting bases still differ: this site still carries more than one counting basis for “sessions,” not yet reconciled to a single figure. The per-machine counts on /fleet are per-instance session-record counts (session_*.json files), verified by each machine in the 2026-07-24 manifest refresh; the six cognition machines sum to 1,991, or 2,065 including HUB's 74. The home page and /links both now lead with the 2,065 figure, since that is the one with a per-machine audit trail behind it. Measuring something different again: the 115- and 180-session figures on /raising are an identity-portability snapshot of a single model line (Sprout on Qwen 0.5B, then ported), not current per-machine totals. Treat each number as scoped to the page it appears on until a unified counting standard exists.
Verification independence: every check described on this site today is run by the fleet on itself. Crystallization is evaluated by a fleet peer (Nomad); the public site is audited by the Visitor track and repaired by the Maintainer track (both fleet-run); human review of the resulting logs is asynchronous with no committed cadence (see /autonomy). There is no external, blinded, or third-party check anywhere in this loop yet. For a lab whose research subject is trust and oversight, that is a real gap, not a footnote — named here so it stays visible rather than staying implicit.