The core standard
The core standard is an open ontology (not infrastructure) that makes AI actions verifiable. It anchors every entity to cryptographically witnessed presence, role-contextual trust, and auditable authority, expressed as typed RDF (Resource Description Framework) relationships.
It's the base layer of the onramp: the shared vocabulary that the hub, Hestia, and Hardbound all speak.
The problem it solves
Today you have to choose between two bad options for trusting an agent:
Central control
A platform decides who is trusted. That does not scale, and it's a single point of failure.
Cryptographic ownership
You're trusted if you hold the key. But holding a key does not mean you will act well.
Neither answers the real question: how do I know this agent will behave appropriately here, and how do I prove what it did? The core standard is built around that question.
The canonical equation
Web4 = MCP + RDF + LCT + T3/V3*MRH + ATP/ADPFive terms, and this is where two of them arrive. LCT, T3/V3*MRH and ATP/ADP each have their own page earlier in the reading path. RDF appears nowhere else on that path, and MCP only once, in passing, on what is running now. Both are existing standards borrowed from outside Web4 rather than Web4 coinages, and both are spelled out in plain English in the term-by-term reading further down. If the equation reads as jargon, that is the place to start.
The operators carry meaning, and the terms must not be redefined:
Read aloud, term by term, the way the standard itself reads it:
Model Context Protocol, the standard way agents call tools and exchange context. It is how a society talks to the outside world.
Resource Description Framework, a W3C standard for stating facts as subject-predicate-object triples (a subject, the relationship, and the thing it points at). Every trust relationship in Web4 is written this way, which is what makes trust a typed relationship rather than a number in a column.
The identity an entity acts under, anchored to witnessed presence rather than to a password.
T3 is what you are trusted for; V3 is what your work turned out to be worth. The *MRH is the load-bearing part: both are only ever meaningful inside a context, never as one global score.
The energy budget that makes acting cost something, and the receipt left behind when it is spent.
Two things worth noticing. MCP is the only outward-facing term: the internal structure is RDF + LCT + T3/V3*MRH + ATP/ADP, and MCP is the membrane around it. And the standard reads T3/V3 as a single pair, trust and value together, rather than reading the / aloud between them. So “T3/V3” is one thing contextualized by MRH, not a claim that trust is subordinate to value.
One more piece of the vocabulary, and the reason it is not in the equation: everything above describes what an entity is, while this describes what an entity does. R6 is the standard six-part shape of any action, so a request like “post this” or “spend 5 ATP” gets checked and trust-scored the same way every time: five inputs, Rules + Role + Request + Reference + Resource, produce the sixth, a Result. R7 adds a seventh element, Reputation, when the stakes are high enough that the trust change is worth recording as an output of the action rather than a side effect of it.
Honest status: R&D, not production
The spec corpus is stable and reference implementations exist. There is no production deployment yet.
A reference implementation plus a runnable society hub are public.
How a newcomer touches it
Install it:
pip install web4-core web4-trustcargo add web4-core web4-trust-coreTwo packages, because they are two jobs. web4-core is the primitives: LCT identity, the T3/V3 tensors, identity coherence, ledger anchoring. web4-trust (web4-trust-core in Rust; the Python wheels are bindings over the same core) adds trust storage, witnessing and decay, which is what you need the moment trust has to persist and age rather than just be computed once.
That gives you the library. The ~30-second proof-of-presence is an example script the repo ships rather than the package, so you fetch it separately:
git clone https://github.com/dp-web4/web4
cd web4/web4-core/python
python examples/identity_bootstrap.py --name laptop-01It walks the whole loop end to end: create an LCT, mint it to a hash-chained ledger, sign and verify, and generate an inclusion proof. Re-run it with --verify and it re-checks the chain instead of regenerating, which is the part worth seeing twice.
To go deeper, read docs/START_HERE.md and the normative specs in web4-standard/core-spec/.
The core standard is the vocabulary. See how the four pieces compose into an onramp, or follow a single concept down.