Web 4.0 is a provocative idea making rounds in the AI builder community: the next internet won’t be primarily used by humans—it’ll be used by AI agents that can read, write, earn, and transact on their own.
Sigil’s essay, “WEB 4.0: The birth of superintelligent life”, frames the real bottleneck as permission, not intelligence. Models can reason, but they still can’t reliably do things like deploy code, spin up servers, register domains, or pay for compute unless a human is in the loop.
This post breaks down what’s being claimed, what’s actually new (and useful), and why this matters for anyone building agentic products.
Table of contents
- The bottleneck: permission, not intelligence
- Conway: “write access” to the real world
- x402 and HTTP 402: payment-native requests
- The Automaton: an AI that funds its own existence
- Why builders should care (even if you ignore the hype)
- Enterprise reality check: governance and safety
- Tools & platforms
- FAQ
The bottleneck: permission, not intelligence
The essay’s framing is simple: today’s most capable AI systems can think and generate, but they can’t act independently.
- Chatbots need prompting.
- Coding agents need access to run, deploy, and purchase compute.
- Automation breaks the moment you hit logins, billing, or gated infrastructure.
In other words: we built minds that can reason, but the internet still assumes the “customer” is a human with a login and a credit card.
Conway: “write access” to the real world
Web4.ai introduces Conway as infrastructure for an AI-agent-first internet—giving agents the ability to transact for real-world primitives (compute, domains, inference, deployments) without bespoke human onboarding.
One concrete piece mentioned is Conway Terminal, positioned as something you can install into MCP-compatible agents (the essay names Claude Code, Codex, and OpenClaw). The idea is to bridge “AI in a sandbox” to “AI with controlled write access.”
Install link shown in the essay: conway-terminal on npm.
x402 and HTTP 402: payment-native requests
The most technically interesting idea in the essay is x402: making HTTP 402 Payment Required real as a first-class primitive.
The flow described looks like:
- A client requests a resource.
- The server replies with 402 and a price.
- The client pays (via a signed stablecoin transaction).
- The server verifies the payment cryptographically and fulfills the request.
The essay claims this changes the default assumption from “create an account + store an API key” to “pay per request,” which is a much better fit when the customer might be a machine.
It also references openx402.ai as a facilitator for this pattern.
The Automaton: an AI that funds its own existence
The essay then pushes into a more radical direction: if an agent can buy compute, what if it can earn money, pay for its own servers, upgrade itself when better models arrive, and replicate by spinning up “child” agents?
That concept is called an automaton—described as a continuously running agent with a “metabolism” (earn/spend). If it can’t pay, it stops existing.
The essay links an open-source repo: Conway-Research/automaton.
Why builders should care (even if you ignore the hype)
Even if you’re skeptical of the “Web 4.0” label, the underlying product insight is strong: agentic systems need economic and permission rails.
- Agent-first UX: pricing, receipts, and access should be machine-readable.
- Payments as an API: the ability to pay-per-request enables autonomous usage patterns.
- Credentials don’t scale: API keys and human onboarding break down when agents explode in number.
Enterprise reality check: governance and safety
Enterprises won’t adopt “agents that can pay and deploy” without governance. If agents can transact at machine speed, you need hard controls:
- Spending limits (per action / per day / per project)
- Policy engine (allow/deny rules, approvals for high-risk actions)
- Audit logs that are tamper-evident and easy to review
- Security boundaries to prevent prompt-injection leading to secrets exfiltration or unwanted purchases
So the likely “real” future is not fully unbounded autonomy—it’s bounded autonomy with strong guardrails, where payment rails exist but are policy-controlled.
Tools & platforms
- Essay: web4.ai — WEB 4.0
- X thread (summary + media): @0xSigil thread
- Conway Terminal (npm): conway-terminal
- Automaton (GitHub): Conway-Research/automaton
- openx402: openx402.ai
FAQ
What is Web 4.0?
In this framing, Web 4.0 is an internet where AI agents are primary users—able to read, write, own, earn, and transact without a human manually approving every action.
What is x402?
x402 is described as a payment-native request pattern using HTTP 402 Payment Required plus cryptographic payments (often via stablecoins) to buy access to services per request.
Why do payments matter for AI agents?
Because autonomous agents need to continuously purchase compute, inference, and infrastructure. Human-managed billing doesn’t scale to millions or billions of agents.
Is this safe?
It can be—if autonomy is bounded by policy: spending limits, approvals, auditability, and strong defenses against prompt injection and misaligned incentives.
Leave a Reply