Web4
Web3 vs Web4: What Actually Changes
Ownership was the Web3 question. Execution is the Web4 question.
The two terms get set against each other as though one replaces the other, usually by people with an interest in the outcome. They are not competitors. Web3 answered a question about ownership. Web4 asks a question about agency. The second question only became urgent because the first one was partly answered.
What follows is a comparison across the six layers where the difference actually shows up, plus an honest note on what Web3 got wrong - because the corrections matter more than the continuities.
The one-line version
Web3 changed who holds the asset. Web4 changes who moves it.
Under Web2, both were the platform. Web3 moved the first to the user. Web4 moves the second to software the user delegates to. Notice that this makes Web4 dependent on Web3 rather than opposed to it: an agent that can move value needs value that can be moved without a platform's permission.
Layer by layer
| Layer | Web3 position | Web4 position |
|---|---|---|
| Core question | Who owns this, and who can take it away? | Who may act, on whose authority, within what limits? |
| Primary user | A person with a wallet. | Software with a mandate, acting for a person. |
| Identity | A key pair. Pseudonymous by design, and deliberately unlinked from a legal person. | A delegation chain. The agent's identity is uninteresting on its own; what matters is whose authority it carries and how far it reaches. |
| Trust model | Do not trust, verify. Consensus removes the intermediary. | Trust, but bound and revocable. The intermediary is replaced by a scoped credential rather than by consensus. |
| Payments | Peer-to-peer value transfer, priced for occasional human-sized transactions. | Continuous micro-settlement, priced for machine frequency. Fractions of a cent, thousands of times a day. |
| Interface | A dApp, which in practice was a website with a wallet button. | No interface. A described capability an agent calls. |
| Failure mode | Irreversible mistakes. Send to the wrong address, it is gone. | Compounding mistakes. Act on a wrong conclusion eight times before anyone notices. |
What Web3 got right, and it is worth naming
Cheap dismissal of the whole period is as lazy as the hype was. Three things came out of it that Web4 depends on and could not easily have been built otherwise:
- Bearer assets that software can hold. An entitlement that exists as a key-controlled claim rather than a row in someone's database is something an agent can hold, prove and transfer on its own. Nothing else has this property.
- Settlement without a relationship. Two parties who have never met, with no shared bank and no contract, can settle in seconds. Agents create that situation constantly.
- Programmable conditions. Escrow that releases on a verifiable condition, with no dispute team in the middle. Narrow, but exactly the shape of problem an autonomous transaction produces.
What Web3 got wrong, which is the more useful list
- It optimised for the wrong scarcity. Enormous effort went into proving that a digital item was unique. Almost none went into proving where it came from. Generative models then made origin the only interesting question - see provenance.
- It treated pseudonymity as an end. For a financial system with no counterparties to please, that is coherent. For an economy where an agent must prove it is allowed to spend your money, it is exactly backwards. Web4 needs verifiable delegation, which is closer to a credential system than to a pseudonym.
- It assumed humans would operate it. Seed phrases, signing prompts, gas estimation - all designed around a person reading a screen. Every one of those becomes a design problem when the operator is software with a spending limit.
- It confused the ledger with the application. Most of what was built on-chain did not need to be. The lasting parts are infrastructure: settlement, identity anchoring, verifiable timestamps.
Where the two actually meet
Strip the vocabulary from both and the overlap is a short list: identity that a stranger can verify, payment that works at machine granularity, and a record of authorisation that survives a dispute. That is the entire intersection - covered in detail here - and it is smaller than either camp claims but genuinely load-bearing.
Everything else an agent does runs on ordinary infrastructure. The model is centralised. The memory is a database. The tools are HTTP. Anyone selling a decentralised version of those is selling the ledger, not solving a problem.
A practical way to tell which era a problem belongs to
Ask what happens if the thing is taken away.
- If the risk is someone confiscates or censors it, it is a Web3 problem. The answer involves keys.
- If the risk is software does something on your behalf that you did not intend, it is a Web4 problem. The answer involves scopes, limits and audit.
Most real systems have both, which is why the two agendas keep converging in practice while their advocates keep arguing. The Web4 overview sets out the full stack; if you want the layer where this gets concrete first, it is identity.