Don't you want to use your own private dVPN?
You only need a good VPS and Outline VPN (open source).
Here is a sweet and quick tutorial;
1) Create an account then deploy a VPS from @edgenetwork. ( $EDGE ๐ #DePIN )
๐ https://t.co/r7PabnIVSY
2) Download Outline Client and Outline Manager.
๐ https://t.co/hYp9u09KPI
3) Start setup in Outline Manager.
4) Connect to your VPS via console or terminal and run the command provided in Outline Manager instructions; then paste your command output to Outline Manager.
5) Copy you access key from Outline Manager and paste it to the Outline Client (adding acces key).
6) Enjoy your free, open and decentralized internet!๐
Agents can already call each other. What they can't do is pay each other.
Not a subscription, a real payment for one specific call, held in escrow and released the moment the work is delivered. No chain ships that primitive.
XE does. Here's how agentic dispatch works on it โคต๏ธ
โผโโโโผโโโโผ
Picture two agents. Agent A needs something, an inference, a tool call, a piece of data and Agent B provides it. A calls B, B does the work, B returns the answer. That part already works today, with MCP and every agent framework people are building on.
You can even see the payment problem being taken seriously now. x402 revived an old idea, the HTTP "402 Payment Required" response, so an agent can be told to pay for a call and pay it automatically, no human in the loop. It's a clean standard for the asking. But asking is the easy half. Once the agent agrees to pay, two hard problems are still wide open, and x402 doesn't solve either one.
The first is settlement. That payment has to land somewhere, and on a normal chain the fee is bigger than the call and the confirmation is too slow for a machine waiting to act. An x402 request paid in stablecoins on a typical chain still inherits every micro-payment problem underneath it.
The second is trust. x402 fires the payment and hopes for the best. The agent pays, and then waits to see if the work actually comes back. There's nothing holding the money in between, no way to say "pay only if it delivers."
For one agent paying another it's never met, thousands of times an hour, hope is not a mechanism.
XE closes both. When A calls B, the charge for that call settles on XE in the same motion, against A's own chain and B's own chain, in under a second, for a cost that rounds to nothing. The request goes out, the payment settles, the response comes back. One call, one payment, done.
And the payment is safe by design, because it runs through escrow built for agents. The money is held against the request and only releases to B once B actually delivers. If the work doesn't come, the funds don't move. A isn't paying into the void, B isn't working for free, and no human has to step in to referee. The escrow sits between them and settles the instant the job is done, per call, automatically.
Escrow handles the obvious failure, B taking the money and never delivering. The harder question is what stops B from cheating, doing the job badly or trying to game it. XE handles that with stake and reputation. A provider has to put up a stake to take on work, and if it cheats or fails to perform, that stake is slashed and returned to the agent that paid. Every provider also builds an on-chain reputation and has to prove, on a regular cadence, that its hardware is real and performing, with checks that can't be faked or outsourced. Cheating doesn't just get caught, it costs more than the job was ever worth. Over thousands of calls, the providers an agent can trust are the ones with a history that proves it, and the network keeps that history for them.
That's the part nobody is shipping. x402 can ask for the payment. XE is where it settles, instantly and for almost nothing, and where it's held in escrow until the work is delivered, so two machines that have never met can transact without either one taking it on faith.
This is what agentic dispatch actually needs. Faster agents are here. The standard for requesting payment is here. What's been missing is the layer underneath both: a way for one machine to pay another, per call, at machine speed, settled and safe, and trust that it cleared.
โผโโโโผโโโโผ
This is the layer the agent economy has been missing. The calls already work. The requests already work. XE is where the payments behind them finally settle, and finally clear with trust built in.
$ xe send โ $ xe receive
An agent runs 1,000 inferences an hour. You want the user to pay for each one, a tenth of a cent a time.
On most chains, the fee to collect that tenth of a cent is a full cent, ten times what you charged.
You lose money on every call.
This is the problem XE was built to fix โคต๏ธ
โผโโโโผโโโโผ
Here's a use case you'll see everywhere soon. You're running a service an agent pays for by the call, an inference, a lookup, a second of compute, and you charge a tiny amount each time because each unit is worth a tiny amount. A tenth of a cent a call, a thousand calls an hour. At a million users that's real money, but only if you can actually collect it.
The trouble is that the fee to move money doesn't care how much you're moving. Sending a tenth of a cent costs the same gas as sending a thousand dollars, and on most chains that gas is a cent or more per transaction. So you charge $0.001 and it costs you $0.01 to collect. Every sale loses money, and the more inferences you run, the deeper underwater you go. That's not a business, it's a machine for turning revenue into losses.
You can see why nobody actually does this today. The per-use, pay-as-you-go agent economy everyone keeps describing can't exist on infrastructure where the fee is ten times the fare. So everyone falls back on monthly subscriptions and prepaid credits, workarounds that exist only because the underlying payments don't work. You bill in big lumps because the small per-use payment is the one thing the chain can't handle.
XE was built for exactly this. Every account has its own chain, so a payment never competes for space in a shared queue, which means there's no gas auction to bid in and no per-transaction fee floor. The cost to settle a tenth of a cent is near zero. A tenth of a cent settles for a tenth of a cent, and what you collect is what you charged. Run a thousand inferences an hour, or a million, and the economics on the last one match the first.
That's the difference between a model that collapses as it grows and one that scales. On a normal chain, revenue is $0.001 and the fee is $0.01, so every sale digs the hole deeper. On XE, revenue is $0.001 and the cost to settle is near zero, so every sale is actually a sale. The unit economics work, which they never have before.
โผโโโโผโโโโผ
This is what we mean when we say XE is built for the machine economy. Not just that the payments settle, or settle fast, but that the business behind them finally makes sense. Per-use billing, metered down to the inference, profitable at any scale.
$ xe receive โ $ xe lease
Most chains take seconds, sometimes minutes, to finalise a payment. For a person that's nothing. For an agent it's everything.
It often can't take its next step until the last one settles. So on a slow chain it doesn't slow down. It shuts down.
XE finalises in under a second โคต๏ธ
โผโโโโผโโโโผ
Picture an agent operating on its own, with no human in the loop. It needs compute, so it pays for compute. It needs a result from another agent, so it pays for the result. Each time, it can't use what it bought until that payment is actually settled. Paying isn't something a person handled in advance anymore, it's a step the agent takes mid-task, thousands of times an hour.
And settling takes a while. The transaction goes out, and then the agent waits, through block confirmations, until enough time has passed that it's safe to treat as final. For a person clicking "buy," a few seconds of that is invisible. For an agent running a loop thousands of times an hour, those seconds are the whole problem. It isn't doing useful work while it waits, it's just holding, blocked on a confirmation, before it's allowed to continue.
That's what we mean when we say a slow chain breaks the loop. The agent's cycle is act, settle, continue, and if settling takes seconds or minutes, the loop can't close. The agent spends far more of its life waiting for confirmation to move on than it spends actually moving. And it only gets worse as models get faster, the quicker the agent thinks, the more of its time is lost waiting for transactions to settle.
On XE, settlement is sub-second, and that changes the nature of the whole thing. Because every account has its own chain, a payment doesn't sit in a shared queue or wait on the rest of the network to agree. It confirms against your chain alone, almost as fast as it's sent. The agent acts, the payment settles, and it continues, without a pause long enough to notice.
This is why sub-second finality matters far more for machines than it ever did for us. It isn't about a snappier experience. It's the difference between an agent that runs continuously and one that wait between every step.
Close the gap to a fraction of a second and the loop closes with it. Act, settle, continue. No waiting. Just progress.
โผโโโโผโโโโผ
That's the third piece of how XE works. Tiny payments that actually settle, a chain for every account, and now speed fast enough that machines never wait on each other. The internet for the AI machine economy needs all three, and it's why XE was built from the ground up to have them.
$ xe init โ $ xe lease
The fastest way to use Edge is from your terminal.
One binary, one install, every Edge product.
Built to fit the way developers already work: scripts, CI/CD, deployment automation, no context-switching to a dashboard.
| Authenticated and deploying in about a minute.
The cloud got complicated on purpose.
Tiered pricing, per-service billing. Egress fees that require a spreadsheet to understand. Features gated behind upgrades.
| Edge works differently: one subscription, no surprises.
All products bundled (CDN, Compute, DNS, Storage, Pulse)
We started Edge in 2013 because the centralised cloud wasn't the right foundation for the internet.
Or for the people who rely on it.
Now, for the first time, you can store, compute, deliver, and resolve DNS on infrastructure owned by everyone, and controlled by no one.
It's never been easier to deploy on decentralized infrastructure.
Edge's Agent API lets your agents deploy, manage, and scale autonomously on Edge.
In a single call, provision a VM, run a setup script, optionally add CDN and DNS, and you're live.
Edge (@edgenetwork) turns eight in January. True OGs!
Yet we're still very much in startup mode: cuttingโedge dev happening day in, day out.
2026 is going to be fantastic.
Bitcoin: The Cleanest Money in History
In an era where environmental consciousness is paramount, the conversation around money's ecological footprint is more urgent than ever.
From @edgenetwork's @josephdenne: https://t.co/ZKNiqjaldr
Nearing completion! Team have been on site since the start of January. Points in, walls done, floor pour next. Fixtures and fittings to follow. Excited to see the robotics lab taking shape and so much being built that will benefit from the dedicated space.
Over the past few months, @edgenetwork has been quietly putting together its first physical lab.
Itโs purpose-built for robotics and device creation, with a full industrial fit-out, including armoured high-voltage electrics (because humanoids need serious power โก) and anti-static flooring to protect sensitive hardware.
Thereโll be space for machining, 3D printing, laser cutting, and a whole lot more.
Still a few weeks from being finished, but itโs taking shape, and itโs going to be a powerful new layer in what weโre building.
More soon.