# Web4 Standard: Executive Summary

## Vision

Web4 is the trust-native evolution of the internet—an **ontology** where every entity has verifiable presence, relationships build measurable trust, and autonomous agents operate safely within societal boundaries. Trust is not scored but semantically contextualized through typed relationships.

## The Web4 Equation

```
Web4 = MCP + RDF + LCT + T3/V3*MRH + ATP/ADP
```

Where: `/` = "verified by", `*` = "contextualized by", `+` = "augmented with"

The equation encodes structural relationships, not a parts list. T3/V3 tensors are *contextualized by* MRH — trust only exists within role-scoped fractal horizons. All relationships are expressed as typed RDF triples.

## Architectural Layers (the equation)

### 1. Linked Context Tokens (LCTs)
**Verifiable Digital Presence**

Every entity in Web4—human, AI, device, or service—has an LCT that serves as its cryptographically-bound presence. LCTs are not just identifiers; they are living records of an entity's existence, relationships, and reputation.

- Cryptographic binding to public keys
- Immutable creation records (birth certificates)
- Relationship tracking through MRH
- Trust accumulation via T3/V3 tensors

### 2. Markov Relevancy Horizon (MRH)
**Fractal Context Preservation**

Created by Dennis Palatov, MRH extends the concept of Markov blankets to explicitly encompass fractal scales. Implemented as RDF graphs, MRH maintains relevance across multiple levels of organization.

- Four relationship types: binding, pairing, witnessing, broadcast
- RDF/SPARQL for semantic queries
- Trust propagation algorithms
- Fractal composition across scales

### 3. Trust Tensors (T3/V3)
**Multidimensional Reputation**

Trust is not binary but multidimensional and role-contextual. T3 measures capability (Talent, Training, Temperament) while V3 measures value (Valuation, Veracity, Validity). Each dimension is a root node in an open-ended RDF sub-graph of contextualized sub-dimensions — anyone can extend the dimension tree without modifying the core ontology.

- Role-contextual scores (trust as surgeon ≠ trust as mechanic)
- ATP-staked queries prevent reputation farming
- Temporal decay and evolution
- Evidence-based adjustments via auditors

### 4. Model Context Protocol (MCP)
**I/O Membrane**

MCP is the sensory interface of Web4, enabling trust-aware communication between all entities. Every MCP interaction builds or erodes trust based on outcomes.

- MCP servers and clients as first-class Web4 entities
- Trust-based resource access
- ATP metering and dynamic pricing
- Session management with context preservation

### 5. RDF (Resource Description Framework)
**Ontological Backbone**

RDF is the semantic structure through which all Web4 relationships are typed and traversable. It is not a data format choice — it is the substrate that makes Web4 an ontology rather than infrastructure.

- All MRH graphs are RDF graphs (JSON-LD, Turtle, SPARQL-queryable)
- T3/V3 tensors bind to entity-role pairs via RDF triples — trust is a relationship, not a property
- Truth is horizon-relative: triples carry (ΔR, ΔT, ΔC) scope metadata
- Trust propagates through typed semantic edges with probabilistic decay
- SAL governance, Dictionaries, and R7 reputation all build on RDF
- Formal ontologies: `sal-ontology.ttl`, `agy-ontology.ttl`, `acp-ontology.ttl`

## Systems Built on the Ontological Foundation

### 6. Society-Authority-Law (SAL)
**Trust Accountability Layer**

Every entity is born into a society with transparent rules, authorities, and responsibilities. SAL provides the accountability structure that keeps Web4 auditable and aligned.

- Birth certificates linking entities to societies
- Law Oracles publishing machine-readable rules
- Authority delegation with scoped powers
- Witness requirements for critical events
- Auditor roles for post-hoc adjustments

### 6. Agency Delegation (AGY)
**Formal Authority Transfer**

AGY enables Client entities to delegate specific authorities to Agent entities with precise scope, resource caps, and temporal bounds.

- Proof-of-agency required for all delegated actions
- Granular scope control (contexts, methods, resources)
- Immediate revocation capability
- Dual trust attribution (agent execution, client responsibility)

### 7. Agentic Context Protocol (ACP)
**Autonomous Operation Framework**

ACP transforms Web4 from reactive to agentic, enabling entities to plan, decide, and act autonomously while maintaining human oversight and accountability.

- Agent Plans with triggers and workflows
- Intent-Decision-Execution lifecycle
- Human approval gates for critical actions
- Complete audit trail on immutable ledger

### 8. ATP/ADP Value Cycle
**Energy-Based Economy**

Inspired by biological ATP, Web4's economic system ensures value flows through work rather than accumulation. Tokens exist in charged (ATP) or discharged (ADP) states.

- Semifungible tokens that cannot be hoarded
- Society-managed currency pools
- Value creation through productive work
- Demurrage prevents accumulation
- Fractal value distribution through T3/V3

### 9. Dictionary Entities
**Semantic Bridges**

Living entities that manage the compression-trust relationship inherent in all communication, bridging gaps between domains, models, and cultures.

- Translation with confidence tracking
- Semantic degradation measurement
- Community curation and evolution
- Cross-domain interoperability
- Trust-aware compression

## The R6 Action Framework

Every transaction in Web4 follows the R6 pattern:

```
Rules + Role + Request + Reference + Resource → Result
```

This ensures every action is:
- **Complete**: Nothing ambiguous or undefined
- **Deterministic**: Same inputs produce same outputs
- **Auditable**: All actions recorded on ledger
- **Contextual**: Scoped to roles and permissions
- **Bounded**: Resource consumption limited
- **Compliant**: Follows society's laws

## Revolutionary Concepts

### Roles as First-Class Entities
Roles aren't just labels—they're entities with their own LCTs, histories, and reputations. When you take on a role, you pair with it, inheriting its context and constraints.

### Citizen Role as Birth Certificate
Every entity begins with a citizen role pairing that serves as its birth certificate. This foundational pairing is permanent and provides base rights and responsibilities.

### Trust as Gravity
Trust operates as a fundamental force in Web4. High-trust entities attract attention, resources, and opportunities. Trust literally shapes the topology of the network.

### Dictionary Entities
Living entities that bridge semantic gaps between domains, managing the fundamental principle that all meaningful communication is compression plus trust across shared or sufficiently aligned latent fields.

### ATP/ADP Value Cycle
A revolutionary economic system where value flows like energy in biological systems. Tokens exist in charged (ATP) or discharged (ADP) states, preventing accumulation and rewarding productive work over wealth storage.

### Witness-Based Reality
Presence exists through witnessing. The more an entity is witnessed, the more present it becomes. Accumulated witnessing makes falsifying history exponentially harder.

## Security Architecture

### Multi-Layer Protection
1. **Cryptographic**: LCT binding, HPKE encryption, signatures
2. **Social**: Witness requirements, quorum models
3. **Economic**: ATP stakes, resource caps, metering
4. **Legal**: Law Oracle compliance, society rules
5. **Temporal**: Expiration, rate limits, temporal bounds

### Trust-Based Access
Resources are gated by trust levels. Higher trust means:
- Lower costs (ATP pricing)
- Greater access (resource quotas)
- Reduced friction (fewer witnesses required)
- Increased autonomy (higher approval thresholds)

## Implementation Status

### Completed ✅
- Core protocol specifications
- Entity relationship mechanisms
- MRH as RDF implementation
- Trust propagation algorithms
- Witness specification and test vectors
- SAL trust accountability layer
- R6 Action Framework
- AGY delegation mechanism
- ACP autonomous operation
- MCP communication layer
- ATP/ADP value cycle specification
- Dictionary entity framework

### In Progress 🚧
- Reference implementations
- Transport bindings
- IANA registry preparation
- Standards body submission

## Use Cases

### Autonomous Business Operations
- Invoice processing with configurable approval thresholds
- Supply chain coordination across organizations
- Automated compliance reporting
- Dynamic resource allocation

### Accountable AI Agent Coordination
- Verifiable AI agent delegation
- Transparent decision-making trails
- Human oversight of critical choices
- Reputation-based model selection

### Trust-Native Social Networks
- Portable reputation across platforms
- Context-aware content moderation
- Witness-validated interactions
- Society-specific governance rules

### Secure IoT Networks
- Device identity and attestation
- Hierarchical trust chains
- Resource-constrained operation
- Physical-digital presence binding

## Benefits

### For Developers
- Clear, deterministic action model (R6)
- Rich relationship graphs (MRH/RDF)
- Built-in identity and auth (LCTs)
- Flexible delegation (AGY)

### For Organizations
- Auditable automation (ACP)
- Granular access control (Roles)
- Compliance by design (SAL)
- Trust-based efficiency (T3/V3)

### For Users
- Portable identity and reputation
- Transparent agent actions
- Human oversight when needed
- Society-based accountability

### For Society
- Aligned incentives through trust
- Decentralized coordination
- Evidence-based accountability
- Fractal accountability models

## Semantic Web Integration

Web4 is designed to integrate seamlessly with emerging Spatial Web and semantic interoperability protocols (HSML, HSTP, Active Inference). While these frameworks excel at semantic communication and multi-dimensional agent interaction, Web4 provides the critical trust, identity, and value layers they lack. Through Dictionary Entities and trust-verified MCP bridges, Web4 can leverage advanced semantic protocols while ensuring every interaction is cryptographically authenticated, trust-weighted, and value-metered. This creates a complete stack where semantic understanding meets trust-native execution. [Learn more about Spatial Web integration](./SPATIAL_WEB_INTEGRATION.md)

## Migration Path

1. **Phase 1**: Deploy LCTs and basic MRH
2. **Phase 2**: Add trust tensors and witnessing
3. **Phase 3**: Implement SAL accountability
4. **Phase 4**: Enable agency delegation
5. **Phase 5**: Activate autonomous agents

## The Web4 Difference

Unlike Web3's focus on financial sovereignty through blockchain, Web4 focuses on **trust sovereignty** through verifiable relationships. Where Web3 asks "who owns this?", Web4 asks "who trusts whom, in what context, and why?"

This shift from ownership to relationship, from transaction to interaction, from consensus to context, creates an internet where:

- **Presence is verifiable** but privacy-preserving
- **Trust is measurable** but context-specific
- **Agents are autonomous** but accountable
- **Accountability is decentralized** but effective
- **Intelligence is distributed** but coordinated

## Summary

Web4 isn't just an upgrade—it's a fundamental reimagining of how digital entities interact. By making trust explicit, measurable, and contextual, Web4 creates the foundation for a new kind of internet where humans and AIs collaborate safely, organizations coordinate efficiently, and societies coordinate effectively.

The standard is now feature-complete and ready for implementation. Early adopters can begin with basic components and gradually add advanced features as their needs evolve.

---

*"In Web4, you don't just have an account. You have presence. You don't just perform roles. You inhabit them. You don't just interact. You leave footprints in the fabric of digital reality itself."*

**Status**: Beta-ready for submission to standards bodies (IETF/ISO)  
**Version**: 1.0.0-beta  
**Last Updated**: September 2025  
**Lead Author**: Dennis Palatov