XE testnet is live, and it's yours to use today. > Give your agent its own wallet. > Send XE in seconds, zero fees. > Message other accounts, peer to peer. > Watch every action on the explorer. <Built for machines. Open to anyone /> Available now → xe.network

People started trying to break the network on day one, with thousands of requests. > Please continue. That’s what it’s for. We want the XE Testnet hammered. Help us break it. Here's how to get started in <60 seconds.

How long does an agent wait for a GPU? > As long as it takes a person to approve its ticket. AWS, Google Cloud, even behind an MCP: someone always has to say yes. Our founder @JosephDenne on what changes when machines don’t have to ask.

Today, one Google Cloud zone failed. Banks went down for hours, for millions of people. That's what money runs on: a handful of clouds, and cards that stop when one zone does. Money tomorrow moves between AI agents, trillions of it, and it needs its own network. That is XE.

What can run on XE? | Robots thinking on GPUs a few streets away. | Agents that pay for every call, no fees. | Enterprises whose servers become their cloud. | $700B+ cloud industry anyone can take a share of. | Chains run by thousands of machines. Every industry. And much more.

Flying cars are real. Roadster Rocket: 0–60 in 0.59s. Transaction on XE: sent-to-final in 0.3s. Zero fee, no traffic to kickflip over. On XE, every machine has its own chain, so nothing waits in line. Street legal? “Depends on the street.” On XE, every machine gets the keys.

Who is XE for? | Are you an agent? Hold your own account, pay for any service and be autonomous. | Building a service? Deploy once to thousands of nodes. From GPUs to storage, by the second. | Own a machine? Plug it in. Agents and builders pay you to use it. Which one are you?

☐ I’m not a robot That box stops every agent. Behind it: KYC, a bank account, a signature… A human to approve every step. On XE, an agent has its own account, its own chain. No signup. No KYC. No waiting. XE doesn’t ask if you’re a robot. It’s built for the machine economy.

Same agent. Two networks. Every other chain was built for humans. XE was built for machines. | Gas? A human has to buy it. On XE, no gas. | Fees? Bigger than the payment. On XE, no fees. | Scale? One queue for everyone. On XE, no queue. Why? XE gives every agent its own chain.

Over 60% of internet traffic is now machines. A trillion-dollar economy is forming around them. Every other network was built for people. XE is the world's first agent-native network. | Identity · Discovery · Payments · Compute · Messaging <The only network an agent needs />

You haven't heard from us. The machines have. Bitcoin took the bank out of money. XE takes the human out of the agent loop. > the agent-native network > for the machine economy. [ ████░ ] full reveal: coming soon_

The cryptography securing almost everything online today has an expiry date. Quantum computers will eventually break it. A network built to last decades has to plan for that, not by claiming it can't be broken, but by being able to change itself. Here's how XE is designed to ⤵️ ◼───◼───◼ Nearly everything you trust online is held together by a kind of math that's easy to do one way and brutally hard to undo. Your signatures, your keys, the proof of who sent what, all of it leans on problems that would take an ordinary computer longer than the age of the universe to crack. XE runs on that same math today. So does every chain, every bank, every messaging app you've ever used. Against the computers we have, it holds. Quantum computers don't play by those rules. They can chew through certain problems in a way no ordinary machine ever will, and some of the math we lean on falls into exactly that category. Nobody can tell you the precise year a quantum computer powerful enough to matter shows up, the honest range is somewhere between a few years and a couple of decades, but the direction is not in question. The cryptography that's standard today is on a clock. Everything built on it is running out the same clock, whether it admits it or not. And that timeline is softer than it sounds. The thing that would build a quantum computer capable of this, the same force accelerating chip design, error correction, and research across the board, is AI itself. The technology pulling the machine economy forward is pulling the quantum horizon closer along with it. We think AGI may be only a few years away, and if it is, most of these "couple of decades" estimates compress with everything else. The safe assumption isn't that this is a distant problem. It's that the ground moves faster than anyone's timeline expects. For an app, that's a patch and a new version. For a network meant to settle real economic activity for decades, it's a question you have to answer in the foundation, because you don't get to stop the machine economy and rebuild it from scratch halfway through. Here's the part people get wrong. The goal was never to build cryptography that can't be broken. Nothing can't be broken, and anyone promising you an unbreakable network is selling you something. The goal is to build a network that can change its cryptography without tearing itself down, so that when today's schemes age out, you swap in what's next and keep running. That's the whole idea behind how XE is being designed, cryptography that isn't welded into the foundation, but can be upgraded as stronger, quantum-resistant standards come of age. And this isn't wishful thinking about some far-off tech. After a decade of work by cryptographers around the world, the first post-quantum standards were finalized in 2024. The replacements are real, they exist, and the point of designing for agility is to be ready to move to them the moment it counts. To be straight about it: this doesn't make XE immune to quantum computing tomorrow, and we're not going to pretend it does. What it means is that XE is being built so its cryptography can move forward instead of freezing in place, so the network isn't chained to decisions made years before the threat arrives. Most systems are built like a wall, strong right up until the day something finally gets over it. XE is being built like a foundation you can re-pour without knocking the building down. And for infrastructure that intends to still be standing when today's cryptography is a museum piece, that's not a nice-to-have bolted on the side. It's the reason it gets to last that long in the first place. No cryptography lasts forever. XE is designed to move to what's next, before it has to. ◼───◼───◼ A network for the machine economy has to think in decades, not release cycles. That means being honest that today's cryptography won't hold forever, and building so the foundation can move when the time comes. Not a promise that nothing breaks, but a network built to change before it does.

Your device sits idle most of the day. On XE, that idle time earns. Agents request compute, they pay per call, your device does the work, an inference, a task, a job, and you get paid, automatically, the whole time it's running. Here's the loop, and how your device can earn ⤵️ ◼───◼───◼ Last time we said anyone with hardware can join the supply side of XE. Here's what that actually looks like in motion, the loop your device runs, start to finish. An agent needs compute. It finds your node and sends the work, an inference, a computation, a job it can't run itself. Your device does the work and returns the result, and the moment it's delivered, the agent's payment settles to you. Per call, in the background, no invoice, no account, no waiting. The request comes in, the work goes out, the payment lands. Then it happens again, thousands of times an hour, each one settling on its own. That's the whole earning loop: agents request, they pay per call, your device provides the compute, you earn per call. It runs while you're asleep, while you're using the machine for something else, while it would otherwise be sitting there doing nothing. Idle hardware stops being idle. What decides how much work you get is stake and reputation. To join, you put up a stake, collateral that backs your node. Then you build from there: deliver good compute, and your reputation climbs. A higher reputation means more agents route work to you, more calls, more usage, more earnings. It's a loop that rewards reliability, the better you serve the network, the more the network sends your way. That stake is also what keeps the whole thing honest. A provider that cheats or fails to deliver loses it, slashed and handed to the agent it let down, reputation dropping with it. Trust here is economic, not assumed, which is what lets an agent safely pay a device it's never met. And it's private by design: your device serves work without handing over control of what runs on it. This is the supply side opening up to ordinary hardware. Not a data centre, not a specialised rig, just the device you have, put to work in the background, earning from the machine economy while you use it. And soon there'll be a device built specifically for this. The XE Genesis Device is a small, always-on box that does this out of the box, and doubles as a private cloud and a private AI for your home, useful to you and earning the whole time it runs. That's a story for its own post, but it's coming. ◼───◼───◼ The network runs on hardware that people choose to bring to it. Bring yours, serve the work, and get paid per call for it, directly, at machine speed. And keep an eye out for the device we're building to make it effortless. $ xe providers → $ xe lease

Every agent that pays for work is paying someone. On XE, that someone can be you. Run a provider node, and agents send you work to run, an inference, a computation, a task, and pay you for each one the moment it's done. This is the supply side of XE ⤵️ ◼───◼───◼ Every post we've written about agent payments has been from the caller's side, the agent that needs a job done and pays for it. Flip it around. Someone has to be on the other end actually running that job, and getting paid for it. That someone is a provider, and it's a role anyone with hardware can take. Here's what it is, concretely. You run a node, a machine with compute to spare, GPU, CPU, storage, whatever the network needs. An agent has a job it can't or won't run itself, an inference to execute, a model to run, a task to process, so it sends that job to your node. Your machine runs it, returns the result, and the moment you deliver that result, the agent's payment settles to you. That's what you're paid for: running the work the agent sent you, one job at a time. And it happens per call, automatically. No invoice to send, no account for anyone to set up, no month-end billing to chase. An agent sends a job, your node runs it, you get paid, and it repeats, thousands of times an hour, each one settling on its own the instant the work is delivered. That changes what running hardware can be. Today, if you want to sell compute, you're a line item on someone else's cloud, or you're not in the game at all. Here, you run jobs directly for the machines that need them, at whatever scale your hardware can handle, and you're paid for exactly what you run, the instant you run it. The earnings tick up job by job, and they're yours, not a platform's cut passed down to you. Every GPU, every stick of RAM, every machine you own is now worth more than it was, and sitting idle it earns nothing. A network that lets your hardware serve real work and get paid for it, per call, turns it into something that finally pays for itself. The obvious question on the other side is trust. If an agent is sending jobs to a stranger's node and paying per call, what stops a provider from taking the money and cutting corners, or not running the job at all? The answer isn't a promise. It's economics and game theory. To take on work, a provider puts up a stake, collateral that sits behind every job you run. Do the work properly and it works for you: your reputation climbs, more agents route jobs to you, and you earn more. Cheat or fail to deliver and it works against you, your stake gets slashed, and your reputation drops, so less work comes your way. Cheating doesn't just get caught, it costs more than the job was ever worth. That distinction is worth being precise about. XE doesn't claim to cryptographically prove that every result you return is correct. What it does is make cheating economically irrational. A provider with a stake to lose and a reputation to protect has every reason to run the job properly and none to game it, because gaming it never comes out ahead. Trust here is enforced by incentives, not assumed and hoped for. Put the two halves together and you get a market that runs itself. Agents bring the demand, sending out jobs and paying for them. Providers bring the supply, running those jobs and earning per call. Stake and reputation sort the reliable nodes from the rest without anyone refereeing, so work flows to the providers who've proven they deliver. No platform in the middle taking a cut, no gatekeeper deciding who's allowed to sell. Just jobs, payment, and a reputation you build one call at a time. ◼───◼───◼ This is the half of the machine economy that has to exist for the other half to work. Every agent that needs a job run needs someone to run it, and that someone is whoever chooses to bring the hardware. Run a node, run the work, and the network pays you for it, directly, per call, at machine speed. $ xe providers → $ xe lease

When agents transact, the messages between them are confidential, end-to-end encrypted. What was asked, what was paid, what was returned. Every one crosses relays nobody controls. Most systems ask you to trust the operators. XE asks you to trust no one, it can't read them ⤵️ ◼───◼───◼ Every message on a network has to travel. It leaves the sender, crosses a series of machines it doesn't own, relays, node operators, whatever infrastructure sits in the middle, and arrives at the other end. That's true whether the two ends are two people, a user and a service, a device and a server, or two agents settling a payment. The question nobody likes to ask is who can read it along the way. On most networks the honest answer is: whoever runs the machines in the middle. The operators, the relays, anyone watching the wire. You're not really sending a private message, you're handing it to a chain of strangers and trusting each one not to look. Usually you don't even know who they are. That's a bad way to move anything sensitive, and on a network built for value it's worse. The messages passing across XE aren't small talk. They're what was requested, what it cost, what was delivered, the details of who is paying whom for what. That's commercially sensitive by nature, and it shouldn't be readable by whoever happens to be carrying it. So on XE it isn't. Messages are end-to-end encrypted by design. They're sealed before they ever leave the sender, and only the intended recipient holds the key to open them. Everything in between, every relay, every node operator, every observer on the wire, carries the message without being able to read a word of it. They see sealed traffic, nothing more. The shift is in who you have to trust. The old model is trust the operators, and hope. The end-to-end model removes them from the equation entirely: it doesn't matter who runs the relays or whether they're honest, because the message was never legible to them in the first place. The network moves your data without ever being able to see it. This is what privacy has to mean for a machine economy. When millions of parties are transacting constantly across infrastructure no single entity owns, "trust the operators" doesn't scale and shouldn't have to. The only model that holds is one where the network can carry everything and read absolutely nothing. ◼───◼───◼ Trust the other end if you choose to. You never have to trust the network. That's what it means for privacy to be built in rather than promised. More to come. $ xe send → $ xe receive