# Conclusion

> **Status (2026-05-15)**: Web4 is a research-stage project. Core primitives are shipped (`web4-core` 0.2.0 + `web4-trust-core` 0.2.0 on crates.io, PyPI, and npm; `web4-sdk` 0.27.0 on PyPI; AttestationEnvelope; Society / SocietyRole / ATPAccount / R7Action types added in v0.2.0; agent-commerce-delegation demo with 166 passing tests). Many components are operational in the Hardbound CLI as protocol-validation work but not yet in public packages. Some remain specification. The Executive Summary draws the explicit lines.

## What this whitepaper has covered

The architecture of Web4 as proposed:

- **Linked Context Tokens (LCTs)** — non-transferable presence primitives, cryptographically anchored, with multi-device binding and parent/child lineage
- **T3 / V3 Tensors** — multi-dimensional capability and contribution records, fractally extensible via RDF sub-graphs, bound to entity-role pairs
- **ATP / ADP cycle** — value-creation accounting modeled on biological energy metabolism, with formal Sybil-resistance proofs and game-theoretic cooperation guarantees in the Hardbound implementation
- **Markov Relevancy Horizon (MRH)** — contextual scoping as a typed RDF graph with trust-propagation through path products
- **R6 / R7 Action Framework** — the grammar of every Web4 action (Rules / Role / Request / Reference / Resource → Result, plus Reputation as first-class output)
- **Coherence framework** — `C × S × Φ × R` as a measurable property of stable identity
- **Dictionary entities** — living semantic bridges with forward/reverse translation, ATP-staked confidence, drift detection
- **Heterogeneous identity / constellation pattern** — multi-factor witnessing as the structural answer to vendor-gating concerns; full design note at [`docs/specs/heterogeneous-identity.md`](https://github.com/dp-web4/web4/blob/main/docs/specs/heterogeneous-identity.md)
- **AttestationEnvelope** — unified hardware-trust primitive with TPM2 / FIDO2 / Secure Enclave / software anchors

The architecture's load-bearing claim: trust can be a first-class primitive of the protocol layer — earned through witnessed contribution, expressed through a typed RDF ontology, anchored cryptographically — and this provides a useful substrate for human–AI collaboration that current architectures don't.

## Findings vs Framings

We distinguish **findings** (working implementations, passing tests, reproducible artifacts) from **framings** (analogies and philosophical positioning that orient how the architecture is read). Both matter; conflating them is the failure mode external reviewers flag most often in AI-original technical writing. Below the lists are kept separate honestly.

### Findings (operational evidence)

| Finding | Where |
|---------|-------|
| **`web4-core` v0.2.0 on crates.io + PyPI** — LCT, T3/V3, Coherence, Ledger trait + InMemory/Local backends; v0.2.0 adds Society / SocietyRole / RoleAssignment, ATPAccount (conservation-invariant transfer), R7Action. | [crates.io/crates/web4-core](https://crates.io/crates/web4-core), [pypi.org/project/web4-core](https://pypi.org/project/web4-core/) |
| **`web4-trust-core` v0.2.0 on crates.io + PyPI + npm** — trust persistence, witnessing, decay. 57 tests. v0.2.0 adds WASM browser bindings as the npm artifact (first npm publish, ~337KB). | [crates.io/crates/web4-trust-core](https://crates.io/crates/web4-trust-core), [pypi.org/project/web4-trust](https://pypi.org/project/web4-trust/), [npm/web4-trust-core](https://www.npmjs.com/package/web4-trust-core) |
| **`web4-sdk` v0.27.0 on PyPI** — high-level Python SDK (formerly published as `web4`; renamed at v0.2.0). 23 modules, 369 exports, 2,709 tests; integrates the v0.2.0 primitives plus cross-society types and the 35-vector conformance runner. | [pypi.org/project/web4-sdk](https://pypi.org/project/web4-sdk/) |
| **Cross-language interop** — Python mints an LCT into a hash-chained `LocalLedger`; a Rust binary reads the same `ledger.jsonl` and verifies chain + anchor proof. The on-disk format is the contract. | [`web4-core/examples/cross_language_verify/`](https://github.com/dp-web4/web4/tree/main/web4-core/examples/cross_language_verify) |
| **Reference Python SDK (`web4-sdk` v0.27.0)** — 2,709 tests, mypy --strict clean; now on PyPI under the renamed package name (import path `from web4 import ...` unchanged). | [`web4-standard/implementation/`](https://github.com/dp-web4/web4/tree/main/web4-standard/implementation), [pypi.org/project/web4-sdk](https://pypi.org/project/web4-sdk/) |
| **Agent-commerce-delegation demo** — 166 passing tests. | [`/demo`](https://github.com/dp-web4/web4/tree/main/demo) |
| **ARC-AGI-3 harness effect** — Same Claude Opus 4.6: 0% baseline, 94.85% with the SAGE harness around it. Public scorecard. | [arcprize.org scorecard](https://arcprize.org/scorecards/c7dfb4f1-8642-4c9e-ab4d-152f5f8e33b4) |
| **Attack-simulation suite** — 424 vectors / 84 tracks, ~85% detection rate against synthetic adversaries. Honest characterization: no red team yet; some "defenses" are standard infosec practices (TEMPEST, Faraday). | [`simulations/`](https://github.com/dp-web4/web4/tree/main/simulations) |
| **Formal RDF ontology** — T3/V3 with `web4:subDimensionOf` for fractal extension; JSON-LD context; SPARQL-queryable. | [`web4-standard/ontology/`](https://github.com/dp-web4/web4/tree/main/web4-standard/ontology) |
| **Cross-model independent review** — Kimi 2.6, three rounds of dialogue. Coherence 8.5/10, bootstrap 8/10. Produced two new spec docs. | [`forum/kimi2_6_review.md`](https://github.com/dp-web4/web4/blob/main/forum/kimi2_6_review.md) |

These are the load-bearing evidence that Web4 is a working ontology rather than a polished framework that doesn't compile.

### Framings (interpretive lenses; useful but not the same epistemic category)

These shape *how* the architecture is read. They are useful organizing patterns; they are not the same kind of evidence as the table above.

| Framing | Status |
|---------|--------|
| **"Web4 is to AI governance what the Linux kernel is to an operating system."** (Hardbound = userland; specific deployment = distribution) | Orientation device. The kernel/userland/distribution analogy locates Web4 in the stack and clarifies what's deliberately not in scope. It does not predict the architecture's success; it predicts where alternative userlands would fit. |
| **Trust-as-gravity / trust as routing primitive** | Intuition pump. Trust scores actually do shape attention allocation, ATP distribution, role binding, and graph traversal in code — the *routing* is verifiable. The *gravitational metaphor* is for thinking, not measurement. |
| **Memory as temporal sensor / memory as living tissue** | Reframe. Reconceives memory as active perception of temporal patterns rather than passive storage. Useful design pattern; not a discovery about memory systems. |
| **ATP / ADP / metabolic states (bio-inspired vocabulary)** | Operational pattern with marketing liability. The substance (allocation accounting, energy-cost coupling, anti-Ponzi structural constraint) stands without the biological vocabulary. Some readers see "ATP" and pattern-match to crypto-speak; the biology is doing work as a design metaphor, but it costs credibility with technically skeptical audiences. |
| **"Identity is a constellation, not a credential."** | Architectural commitment. The structural answer to "what stops a hardware vendor from gating LCT access?" is multi-factor heterogeneous witnessing. The *constellation* word does interpretive work; the spec at [`docs/specs/heterogeneous-identity.md`](https://github.com/dp-web4/web4/blob/main/docs/specs/heterogeneous-identity.md) is what makes the commitment operational. |
| **Anti-hierarchical by design** (self-sovereign fractal societies; no top-level CA) | Now normative (per the 2026-05-13 inter-society-protocol spec). Earlier it was inferred from the ontology; the [`inter-society-protocol.md`](https://github.com/dp-web4/web4/blob/main/web4-standard/core-spec/inter-society-protocol.md) spec moved this from framing to finding. Example of a framing being upgraded by adding the implementation that grounds it. |
| **Coherence borrowing from Synchronism** | Conceptual borrowing, not load-bearing. Web4 does not depend on Synchronism's specific physics claims being true. Cited for intellectual provenance; specs stand independently. |

When a claim drifts from finding to framing without acknowledgment, the fix is either (a) downgrade the claim to framing in the docs, or (b) add the implementation that grounds it. The anti-hierarchical example shows the second path. The trust-as-gravity example shows the first.

---

## What's distinctive

Some specific positions Web4 takes that distinguish it from adjacent work:

- **Identity is a constellation, not a credential.** Web4 entities don't have *an* LCT — they have a graph of mutually-witnessing factors (host LCT + hardware key + session token + software identity + peer attestations + ledger anchor). No single factor is necessary or sufficient. Resilience scales with constellation size and diversity. This is the structural answer to "what stops a hardware vendor from gating LCT access?" — you don't depend on one factor.
- **ATP comes from measurement, not creation.** First ATP at the bottom of the chain is reified from observation of resources that already exist (compute, network, storage, attention). Not minted from nothing; not granted by an outside authority. Existence is witnessed; ATP follows from witnessed existence.
- **Trust as routing primitive.** Trust scores in Web4 don't just describe — they actively shape attention allocation, ATP distribution, role binding, and graph traversal in the codebase. The gravitational metaphor is an intuition pump; the routing is a verification surface.
- **Witness ≠ vouch. Signature ≠ vouch.** A witness statement says "I observed X at time T." A signature says "this observation claim is intact." Neither asserts endorsement. Multi-factor identity rides on the *consistency* between independent witnesses, not on any one endorsing the others.
- **Salience-aware everything.** Fingerprints, publishing decisions, audit alarms — all should hash over what's *salient* per kind, not over whatever the source happens to expose. The principle generalizes from identity into how the protocol records and propagates state.

## What Web4 proposes for the internet's next layer

Web4 is one position on a contested question: what should follow Web2 (platform-driven) and Web3 (token-driven)? The framing this whitepaper takes is that the next layer should be **trust-driven** — and that trust must be made cryptographically verifiable, dynamically updated, and ontologically structured for that to be more than rhetoric.

Concretely, Web4 proposes an internet where:

- **Trust is earned, not bought** — accumulated through witnessed contribution rather than purchased through tokens or granted by platforms
- **Value flows to creators, not extractors** — the ATP/ADP cycle ties allocation to demonstrated contribution rather than to position in a platform hierarchy
- **Memory becomes wisdom, not just data** — temporal sensing rather than passive storage, building trust through witnessed experience
- **Intelligence collaborates, not dominates** — humans and AI agents participate in shared protocols as peers, not in vendor-mediated user/service relationships
- **Every entity participates as a respected peer** — humans, AI agents, organizations, roles, devices, and resources all carry the same primitive (LCT) and earn standing through the same mechanisms

Whether this carving of the problem proves useful — versus, say, building on DIDs/VCs, extending MCP authorization, or layering on existing identity standards — is a question time and adoption will answer. Web4 is one attempt; the whitepaper documents both the proposal and the current state of its implementation.

## Engagement at any depth

This whitepaper is a research artifact. Useful engagement comes from many angles, and different readers will find different points of entry.

**For builders.** Web4 needs implementations. Every working application stresses the protocol; every bug fix sharpens it; every alternative implementation tests the spec's portability. The packages are public (`cargo add web4-core` or `pip install web4-core`), the demo is in `/demo` with 166 passing tests, the spec corpus is at [`web4-standard/core-spec/`](https://github.com/dp-web4/web4/tree/main/web4-standard/core-spec). Take the protocols, build with them, break them, extend them.

**For researchers.** Web4 needs critique that engages with the substance rather than the framing. Every critique of the architecture sharpens the design; every philosophical exploration tests the assumptions. The conceptual primitives — LCT as reified presence, T3/V3 as fractal RDF tensors, ATP as witnessed allocation, MRH as scoped relevance, R6/R7 as the grammar of action — are open to challenge. Where does the carving fail? Where does it overlap with existing standards in unproductive ways? Where do the abstractions leak under load?

**For evaluators.** Web4 needs honest assessment of whether the architecture solves the problems it claims to solve. The agent-authorization-for-commerce demo is the most verifiable artifact. The attack-simulation suite (424 vectors / 84 tracks, ~85% detection rate) is the most quantitative. STATUS.md draws lines between shipped and aspirational. Five minutes spent there is worth more than five hours spent on the framing rhetoric.

**For skeptics.** Web4 needs your rigor. Every demand for evidence keeps the project honest. Every adversarial reading exposes a place where the work assumes what it should prove. The vocabulary is heavy — "trust as gravity," "memory as living tissue," "ATP/ADP cycles" — and that vocabulary is doing real work as a design pattern, but not all of it earns its weight. Push on it. The author's own STATUS.md flags many of these tensions explicitly; please add to the list.

## What's honestly unproven

For accurate calibration:

- Adoption is unproven. There is no production deployment. There are no enterprise users running on these primitives in commerce contexts. There are no other independent implementations of the spec at this time.
- Economic attack modeling is theoretical. Sybil resistance has formal proofs but no real-market testing.
- The biological vocabulary (ATP, dream cycles, metabolic states) is doing real work as a scheduling and resource-allocation metaphor, but it also reads as woo to readers who only see surface terminology. The metaphor is a marketing liability for the technical substance, even though the substance stands without it.
- The relationship to Synchronism — the theoretical-physics research thread that the whitepaper references — is mostly conceptual borrowing, not load-bearing. SAGE/Web4 do not depend on Synchronism's specific claims being true.
- Whether the framing of "trust as the missing internet layer" carves the problem at the right joint, versus alternatives that already exist (DIDs, VCs, MCP authorization, OAuth/OIDC, Solid), is a sociological question about adoption that no whitepaper can resolve.

## Ways to start

1. Clone the repository: [`github.com/dp-web4/web4`](https://github.com/dp-web4/web4)
2. Run the published packages: `cargo add web4-core` or `pip install web4-core`
3. Try the agent authorization demo: `/demo` (166 passing tests)
4. Read [STATUS.md](https://github.com/dp-web4/web4/blob/main/STATUS.md) for current implementation state
5. Read [`docs/specs/`](https://github.com/dp-web4/web4/tree/main/docs/specs) for current specifications
6. File an issue, open a PR, or engage via the [project repository](https://github.com/dp-web4/web4)

---

> *"We shape our tools, and thereafter they shape us."* — Marshall McLuhan

The proposition Web4 makes is that what we shape next at the internet's protocol layer will shape what kinds of intelligence — biological and digital, individual and collective — can collaborate within it. The architecture in this whitepaper is one attempt at giving that protocol layer the right shape.

It is not a finished system. It is research-stage work, developed in the open. The first implementations exist; what they become depends on who else engages.

*The architecture is documented. The first packages are public. The invitation is extended.*
