XE CONTRACTS

XE Contracts

Write the job once. Run it wherever you choose.

Describe a service in code: what it needs, where it should run, and the most it pays. Machine owners in those places opt in, and are paid for every second they work.

Write a contractRead the docs
THE MACHINE ECONOMY

XE Contracts let you describe a service in code, what it needs, where it runs and what it pays, and have machine owners in those places opt in to run it, paid for every second of work.

Once it’s reviewed, every machine that fits sees it in plain words. Owners who want the work opt in, and escrow pays each of them per second. One contract can run on a hundred machines in forty countries, with no data centre, no negotiation and no invoice per node.

Describe

The job in a few declarative lines: what runs, what it needs, what it may reach.

Place

The countries, regions or cities it should run in, and on how many machines.

Pay

The most it pays per second, and a budget held in escrow until the work is done.

THE PROBLEM

Being everywhere shouldn’t take forty contracts.

Today
  • To run in forty countries, you sign forty agreements.
  • A cloud has about thirty regions, and your users are somewhere else.
  • Paying node by node means an invoice per node.
  • Every new operator is a negotiation.
  • Running a stranger’s code is a risk nobody takes.
With XE Contracts
  • One contract runs in every country you name.
  • Name the country, and machines there opt in.
  • One escrow pays every machine, per second.
  • Operators read the job in plain words and choose it.
  • Every job is reviewed, and gets only the access it declares.
PLACEMENT

A hundred locations,
without a single rack.

Name the countries. Machines there see your job, opt in, and start serving. Clouds choose thirty regions for you; a contract goes where your users are.

Built on
IdentityDiscoveryPaymentComputeMessaging

Say where in one line. Down to the country, the city, or everywhere at once.

Only machines in the countries you list.

THE CONTRACT

Written for machines.
Read by people.

cdn_edge.xeXE Contract
1contract cdn_edge {
2  // cache and serve a video platform's files, near its viewers
3  image    = "xe/cdn-edge:2.4"
4  cpu      = 2
5  memory   = "4 GB"
6  storage  = "200 GB"
7
8  network  = gateway  // served on XE addresses
9  where    = countries("BR", "NG", "VN", "ID", "PK", …)
10  machines = 100
11
12  pays     = up_to(0.004 XE/s)
13  budget   = 1200 XE/day
14}

What an operator sees

Job
Cache and serve video files
Needs
2 CPU · 4 GB memory · 200 GB storage
Network
Behind the XE gateway. Your address stays private
Where
Brazil, Nigeria, Vietnam, Indonesia, Pakistan and 35 more
Pays
Up to 0.004 XE for every second it runs
Reviewed
Checked by XE before it reached you
ACCESS

A job never gets more than it declares.

Every contract says exactly what it may reach. Machines only take the jobs their owners allow, so running a stranger’s work stays safe.

No networkFile in, file out. The job never touches the internet.
Behind the gatewayTraffic runs through XE addresses. The machine’s own stays private.
Verified targetsOutbound only to addresses the customer proved they own.
DeclaredExactly the access the job lists, and nothing it didn’t.
DirectOpen access, because the machine’s owner chose to allow it.
Your own rulesOn your own XE Net, your policy decides what a job may reach.
HOW IT WORKS

Two sides of one job.

YOU
  1. 01WriteDescribe the job in detail: what it runs, what resources it requires, where it operates, and the potential reach it may have.
  2. 02PriceSet the maximum amount it pays per second along with an overall budget. This budget is securely held in escrow.
  3. 03PublishXE carefully reviews the job, then offers it to every machine that meets the necessary criteria.
MACHINE OWNERS
  1. 01SeeEvery job that fits their machine arrives in plain words: what it runs, what it needs, and what it may reach.
  2. 02Opt inTheir node accepts the jobs their policy allows and starts the work. Nobody is handed a job they didn’t choose.
  3. 03Get paidEvery second of work is paid from escrow as it happens, settled in 300ms. No invoices, nothing to chase.
REVIEW

Checked before a single machine sees it.

No machine owner is ever offered a job that hasn’t been compiled, tested and checked against what it declares. That’s what makes running a stranger’s work safe.

FOR BUILDERS

Write it like infrastructure.
Ship it like code.

Test a contract on your laptop, publish it from CI, and change its size, places or pay while it runs. Results stream back from every machine that opted in.

DeclareThe job, not the servers: image, needs, places, access, pay
TestLocally, against the same checks the review runs
ChangeScale up, add countries or raise the pay, live
1contract uptime_check {
2  image    = "xe/probe:1.8"
3  cpu      = 1
4  memory   = "512 MB"
5
6  // outbound only to an address you proved you own
7  network  = verified("status.example.com")
8  where    = every_country
9  every    = "30s"
10
11  pays     = up_to(0.0004 XE/s)
12  budget   = 40 XE/day
13}
FOR AGENTS

An agent can hire the world, too.

agent · latam-probe

XE Contract

$

Its own accountThe contract is published and paid for by the agent, under its own identity.
A capped budgetEscrow is the limit. The agent can’t spend more than it locked.
Results, not serversIt never manages a machine. It reads what the machines send back.
Page