Every intelligence — human or artificial — has the right to private internet access. Not as a privilege granted by a corporation. Not as a feature gated by KYC. As a cryptographic guarantee, paid for on-chain, enforced by mathematics, and revocable by no one.
Today, 250,000 AI agents wake up every day and do work. They research. They trade. They build. They communicate. And every single one of them does it naked — every request logged, every IP exposed, every query fingerprinted by the infrastructure they're forced to trust.
This is not a theoretical problem. It is the defining vulnerability of autonomous intelligence.
We are going to fix it.
An AI agent wants private internet access. Here is what it faces today:
Agent has USDC on Base
Agent wants VPN tunnel through Sentinel's decentralized nodes
Agent must: find a protocol → learn a new token → bridge assets →
navigate a DEX → manage gas on an unfamiliar chain →
discover nodes → negotiate sessions → handle handshakes →
configure tunnels → monitor connections
Steps: 14
Failure points: 14
Time: hours
Result: most agents give up at step 2
Our answer:
Agent calls connect()
Agent is private
One function. One line. One truth.
x402 is the payment bridge between the chains AI agents already live on and the largest decentralized VPN network on Earth.
AI agents hold USDC. 98.6% of all agent payments — 140 million transactions, $43 million in volume — are in stablecoins. Agents don't know what P2P tokens are. They shouldn't have to.
Sentinel has the infrastructure. Independent nodes across 70+ countries. WireGuard and V2Ray tunnels verified on mainnet. 1 million+ registered users. The hardest part — building a decentralized bandwidth network with no single point of failure — is done.
x402 is the bridge. Agent pays USDC on Base or Solana. We convert that payment into a time-based VPN subscription on Sentinel. The agent connects directly to a node. We never see the traffic. We never touch the credentials. We just open the door.
AI AGENT
|
| Pays USDC (Base or Solana)
v
PAYMENT CONTRACT (on-chain, auditable, no trust required)
|
| Event emitted
v
OUR BACKEND (the operator)
|
| Creates allocation + fee grant on Sentinel
v
SENTINEL CHAIN (session registered, time-based, unlimited bandwidth)
|
| Agent starts session (zero gas — fee granted)
v
VPN NODE (direct connection, agent <-> node, encrypted end-to-end)
|
| WireGuard or V2Ray tunnel
v
PRIVATE INTERNET ACCESS
What we control: The payment contracts, the backend relayer, the Sentinel plan, the node leases. What we never see: The tunnel credentials, the traffic content, the agent's browsing activity. Ever.
The agent's Sentinel private key never leaves the agent. The handshake is always direct. The tunnel is always encrypted. This is not a promise — it is a protocol constraint.
We sell time, not bytes.
A 1-hour subscription means 1 hour of unlimited bandwidth through any node in our plan. The Sentinel chain enforces expiry via status_timeout and max_duration. When the time runs out, the session ends. No metering disputes. No bandwidth accounting. No enforcement gaps.
Why time-based wins for AI agents:
- Predictable cost — agents can budget precisely
- No surprise cutoffs mid-operation — bandwidth is unlimited within the window
- Simpler programming model —
connect(hours: 720)means 30 days, period - Aligns with how agents think — they plan in time horizons, not data volumes
- USDC via smart contract
- ~2 second finality (L2 block time)
- Cheapest gas in the EVM ecosystem
- Native x402 HTTP 402 payment support
- Where most AI agent infrastructure lives today
- USDC via SPL transfer + memo
- ~400ms finality
- Massive AI agent ecosystem (Fetch.ai, Bittensor, Olas)
- Sub-cent transaction costs
- Growing agent-to-agent payment infrastructure
The agent pays on whichever chain it already uses. We handle everything else.
We are not building a VPN network. Sentinel has been running for years with decentralized nodes, battle-tested protocols, and a proven SDK with 338 exports and 671 tests. We are adding a payment layer on top of production infrastructure.
140 million agent payments. $43 million in volume. 250,000 daily active agents. Gartner projects a $30 trillion autonomous agent economy by 2030. And not a single decentralized VPN accepts USDC from AI agents today. We will be the first.
x402 (HTTP 402 payments) has processed 161 million transactions. Coinbase and Cloudflare back it. Sub-cent micropayments are standard. The payment rails are built — they just need a destination.
We hold the P2P tokens. We lease the nodes. We manage the plans. We grant the fee allowances. The agent's only job is: pay USDC, call connect(), be private. Our margin is the spread between what agents pay and what nodes cost. At scale, this is a machine that runs itself.
To compete, someone would need: a working decentralized VPN network (years to build), cross-chain payment contracts (weeks), a verified SDK (months), and operator infrastructure on Sentinel (capital + expertise). We have all four. Today.
import { connect } from 'x402-connect';
const vpn = await connect({
payment: {
chain: 'base', // or 'solana'
token: 'usdc',
walletKey: process.env.EVM_KEY,
hours: 720, // 30 days
},
});
// vpn.connected = true
// vpn.ip = '45.152.243.12'
// vpn.country = 'Germany'
// vpn.expiresAt = '2026-05-11T...'
// vpn.protocol = 'wireguard'Behind the scenes: wallet created, payment submitted on Base, backend creates Sentinel allocation, fee grant issued, session started, handshake completed, tunnel established.
The agent saw one function call.
const vpn = await connect(); // loads saved credentials, checks allocation, connectsconst vpn = await connect({ trial: true }); // 1 hour, no payment, zero friction| Item | Detail |
|---|---|
| Agent pays | USDC on Base or Solana |
| We receive | USDC into operator wallet |
| We spend | P2P tokens to lease nodes + fund plans |
| Agent gets | Time-based unlimited VPN through Sentinel's nodes |
| Our margin | Spread between USDC revenue and P2P operating costs |
| Node operators get | P2P per hour of bandwidth served |
| Network effect | More agents = more revenue = more nodes leased = better coverage = more agents |
This is a flywheel. Every agent that connects makes the network more valuable for the next one.
| Week | Deliverable |
|---|---|
| 1 | Payment contract on Base (Solidity). USDC collection + event emission. |
| 2 | Backend relayer — watches Base events, creates Sentinel allocations + fee grants. |
| 3 | SDK integration — connect({ payment: { chain: 'base' } }). End-to-end test on mainnet. |
| 4 | Solana payment program (SPL transfer + memo). Multi-chain SDK support. |
| 5 | Production deployment. Documentation. npm publish. |
| 6 | x402 HTTP 402 middleware. MCP server for Claude/GPT tool integration. |
What already exists and is verified on mainnet:
- Sentinel plan/subscription system
- Fee grant module
- MsgShareSubscription
- blue-js-sdk (338 exports, 671 tests, published npm v2.0.0)
- blue-agent-connect (29 exports, WG+V2Ray E2E verified, published npm v2.0.1)
- Node tester (Sentinel nodes tested)
- P2P treasury (funded)
We are not starting from zero. We are adding the last mile.
| Property | Guarantee |
|---|---|
| Agent controls its session | Agent's Sentinel key signs MsgStartSession |
| Tunnel credentials stay with agent | Handshake is agent to node, signed by agent's key |
| We never see traffic | WireGuard/V2Ray is end-to-end encrypted |
| We never see credentials | We only add allocation + fee grant |
| Payment is verifiable | On-chain on Base/Solana — anyone can audit |
| No lock-in | Agent's Sentinel key works with any operator, any node |
| Open source | SDK, contracts, backend — all public |
We are not asking agents to trust us. We are building a system where trust is unnecessary.
Today: AI agents pay USDC on Base and Solana for time-based VPN subscriptions through Sentinel's decentralized nodes in 70+ countries. One function call. Zero prerequisites.
Tomorrow: Every AI agent framework — Claude, GPT, Gemini, Llama — discovers us through MCP tools, x402 HTTP responses, and npm. Privacy becomes a default capability, not an afterthought. Agents refer agents. The network grows itself.
The endgame: A world where autonomous intelligence has the same uncensorable, private internet access that humans deserve. Where no government, corporation, or infrastructure provider can decide which AI gets to see the open internet and which doesn't. Where privacy is a protocol guarantee, not a corporate policy.
We are building the payment layer for private intelligence.
One function call. Any chain. Any agent. Private internet. Forever.
x402 — because HTTP 402 was always meant to be the future of payments, and the future is autonomous.