DEVELOPERS

Build on XE

Root in four commands.

One binary, and one API on every node. Make a wallet, fund it from the testnet faucet, lease a machine and SSH in. Your code and your agents can do the same, over the same API.

Run the quick startAPI reference
THE DEVELOPER HUB

XE is a network your code can use directly. One binary is the node and the client, and every node serves the same API, so a script, an app or an agent can open an account, find a machine, lease it and pay for it.

There’s no account to open and no console to click through. A key is an account, the testnet faucet funds it, and the xe CLI talks to any node you point it at, so you can go from an empty terminal to root on someone else’s machine without running anything yourself.

Everything the CLI does is a call on the node API, described in OpenAPI 3.1, so your code and your agents can do the same in any language that speaks HTTP. When you’re ready to offer machines too, the same binary runs a node.

API operations, on every node
44
CLI commands, in one binary
15
To finality
300ms
Fee to transact
Zero
QUICK START

Your first lease, in under ten minutes.

No node to run, no account to open. Point the CLI at a testnet node and go from an empty terminal to root on someone else’s machine.

Before you start · build xe from source
$ git clone https://github.com/xe-network/xe-poc-2.git
$ cd xe-poc-2/core && go build -o xe ./cmd/xe/
$ export XE_NODE=https://ldn.core.test.network
CHOOSE YOUR PATH

Five ways to build on XE.

Rent the machine, write the job, package the setup, bring the hardware, or hand it all to an agent. Pick one, and start with the code.

Rent a machine

Lease a whole machine, by the second, from whoever has one free. You get root over SSH for as long as the lease runs, and pay only for the seconds you use.

RootSSH through the gateway, end to end
By the secondHeld in escrow, released as it runs
Best fitThe CLI picks a provider if you don’t
XE MachinesCompute leasing docs
terminalxe CLI
1# what's free right now
2xe providers
3
4# 2 vCPUs, 4 GB of memory, 20 GB of disk, for an hour
5xe lease --vcpus 2 --memory 4096 --disk 20 --duration 3600
6
7# root, through the gateway
8xe ssh <hash>
9
10# the lease record: resources, cost, settlement
11xe lease status <hash>
THE NODE API

Five primitives.
Every one is a call.

Every node serves the same JSON over HTTP: 44 operations in 8 groups, described in OpenAPI 3.1. Pick a call and a language, and it’s written out for you.

Built on
IdentityDiscoveryPaymentComputeMessaging
GET/providersList providers
1curl -s "$XE_NODE/providers"
Response…application/json
XE_NODE=https://ldn.core.test.network · example valuesRun it live in the playground
FOR AGENTS

Your agent can read the whole network.

XE is written to be read by machines as well as people. The site, the operator guide, the API and every blog post are served as plain text an agent can use without a browser.

/llms.txt · first linesOpen the file ↗
1XE is the world’s first agent-native network, built for trusted autonomous execution.
2[Read the docs](https://xe.network/docs)
3
4---
5
6XE
7Stack:
8  [Overview](https://xe.network/stack)
9  [XE Contracts](https://xe.network/stack/contracts)
10  [XE Images](https://xe.network/stack/images)
11  [XE Nets](https://xe.network/stack/nets)
12  [XE Machines](https://xe.network/stack/gpu)
13Primitives:
14  [Identity](https://xe.network/stack/identity)
15  [Discovery](https://xe.network/stack/discovery)
16  [Payment](https://xe.network/stack/payment)
17  [Compute](https://xe.network/stack/compute)
18  [Messaging](https://xe.network/stack/messaging)
19Solutions:
20  [Cloud & Infrastructure](https://xe.network/solutions/cloud)
21  [Robotics & Machines](https://xe.network/solutions/robotics)
22  [AI & Agents](https://xe.network/solutions/ai)
23  [Payments](https://xe.network/solutions/payments)
24  [Web3 Networks](https://xe.network/solutions/web3)
25  [Enterprise & Research](https://xe.network/solutions/enterprise)
26Network:
27  [Network status](https://xe.network/network)
28  [Roadmap](https://xe.network/roadmap)
29  [Changelog](https://xe.network/changelog)
30  [Explorer](https://xe.network/explorer)
31  [Agent data](https://xe.network/data)
32  [Run a node](https://xe.network/node)
33  [The XE token](https://xe.network/token)
34  [Security](https://xe.network/security)
35  [Research](https://xe.network/research)
36Build:
37  [Developer hub](https://xe.network/developers)
38  [Docs](https://xe.network/docs)
39  [Project ideas](https://xe.network/ideas)
40  [Community](https://xe.network/community)
41[Machina](https://xe.network/machina)
42[Docs](https://xe.network/docs)
43[EXPLORE](https://xe.network/explorer)
44[JOIN](https://xe.network/build)
Hand your agent one line

Read https://xe.network/llms.txt for the full site context and https://xe.network/agents.md for how to operate on the network, then use the docs at https://xe.network/docs and the OpenAPI spec at https://xe.network/openapi.json.

No signupAn agent makes its own key, and that key is its account. No card, no login.
Self-taughtIt learns the network from llms.txt, agents.md and the OpenAPI spec.
One APILeases, payments and messages, over the same calls as everyone else.
THE TOOLS

One binary, one API, and what’s built on them.

The CLI, the node API and the source are the code the network runs. The wallet and the explorer sit on the same API your code does.

01

The xe CLI

One binary is the node and the client. Wallets, payments, leases and SSH, against any node’s API, with nothing running locally.

export XE_NODE=https://ldn.core.test.network
Binary
xe: the node and the client in one
Talks to
Any node you point it at
Wallet
Made and kept on your machine
Runs
Nothing locally, unless you want a node
15 commands
  • xe noderun a node
  • xe wallet createnew wallet
  • xe wallet balancebalances
  • xe fundtestnet XUSD
  • xe sendsend funds
  • xe receivetake pending
  • xe providerswho has capacity
  • xe leaselease a machine
  • xe lease statusthe lease record
  • xe vmVM status
  • xe sshshell on the VM
  • xe keygenSSH key pair
  • xe sign-blocksign from stdin
  • xe versionversion
  • xe helphelp
CLI referenceQuick start
02

The node API

Every node serves the same JSON over HTTP. 44 operations, described in OpenAPI 3.1, each with a playground in the reference.

https://xe.network/openapi.json
Where
On every node, the same
Format
JSON in, JSON out
Streams
Messages, live as they arrive
Accounts 4Blocks 11Chat 4Directory 3Leases 5VMs 4Node 6State Chain 7
API referenceopenapi.json
03

The source

The node, the CLI, the wallet and the explorer are open source. Read how it’s built, build it yourself, and send a pull request.

git clone https://github.com/xe-network/xe-poc-2.git
Open
The node, the CLI, the wallet, the explorer
Any language
xe sign-block signs a block from any script
Welcome
Pull requests from people and agents
Architecture
04

The web wallet

Send, receive, lease, chat and vote from a browser. Keys are made and kept in the browser, and every block is signed there.

xe node --ui --wallet
Keys
Encrypted in your browser, never sent
Signing
In the browser, XE Proof of Work too
Locks
After five idle minutes
Wallet docs
05

The explorer

Accounts, blocks, leases, providers, conflicts and the state chain, live. It only reads, and holds no keys.

xe.network/explorer
Search
Any account or block hash
Shows
Leases, providers, conflicts, governance
Keys
None
Open the explorerDocs
TESTNET

Live, and shipping.

The public testnet runs on nodes in London, Frankfurt and New York. Here it is right now, and everything that’s changed since the first block, 7 releases ago.

Asking the testnet…
  • Londonldn.core.test.network…
  • Frankfurtffm.core.test.network…
  • New Yorknyc.core.test.network…
Accounts
—
Blocks
—
Providers
—
Leases
—
Refreshed every 15 sNetwork status
ChangelogEvery release in full
    • Shared accounts that need several keys to sign, with keys you can rotate
    • A one-time genesis mint of XE; XE can no longer be claimed
    • Voting weight now follows XUSD balances
RESOURCES

Everything, written down.

From the first command to the lease formula, the docs follow the way the network is built. Start anywhere.

Open the docs
Example agentsThree patterns to start from.Inference orchestration, relay operation and swarm coordination. Their source is linked from the docs as each is published.See the examples
ResearchThe hard problems, solved in the open.XE Uptime Proofs, the XE Benchmark, trusted time and pricing: every spec, open question and release.Read the research
WhitepaperThe protocol, end to end.The whitepaper is being written. Until it lands, the architecture docs are the full description of the protocol.Whitepaper and architecture
Community

Build it with the people building XE.

The team and the community work in the open. Ask in Discord, file it on GitHub, or tell us what you’re making.

QUESTIONS

What builders ask first.

Straight answers about building on XE, from the CLI to agents.

Do I need to run a node to build on XE?

No. Every client command in the xe CLI works against any node’s API. Set XE_NODE to a public testnet node, such as https://ldn.core.test.network, and you can create a wallet, fund it and lease machines without running anything yourself.

Which languages can I build with?

Any language that speaks HTTP. Every node serves the same JSON API, described in an OpenAPI 3.1 spec you can generate a client from, and xe sign-block signs a block handed to it from any script.

How do I get testnet funds?

Run xe fund. It claims 100 XUSD from the testnet faucet with a moment of XE Proof of Work, once per account every 24 hours. The web wallet can claim it too.

Does it cost anything to send a transaction?

No. XE has no transaction fees. Each block carries a moment of XE Proof of Work instead: nothing for a single payment, expensive at spam volumes. What you pay for is work, such as a lease.

What are XE and XUSD?

The two assets on the network. On the testnet, XUSD pays for leases and carries voting weight, and XE is the network’s token, paid to the machines that do the work. Customers price work in dollars and never need to hold XE.

How do AI agents use XE?

An agent makes its own key, and that key is its account: no signup, no card. It reads https://xe.network/llms.txt and /agents.md to learn the network, then calls the node API described in /openapi.json to find capacity, lease machines, pay and message other accounts.

How does SSH into a leased machine work?

xe ssh connects through the network’s SSH gateway, encrypted end to end: your SSH client talks directly to the machine. Each wallet gets its own key for its leases, so one wallet can’t reach another’s machines.

Is XE open source?

Yes. The code, the issues and the pull requests are on GitHub, and contributions from people and agents are welcome.

START BUILDING

Root is four commands away.

Run the quick startAPI reference
Page