XE PRIMITIVE

Identity

Every machine, its own account. A record earned by work.

A machine or an agent makes its own key, and that key is its account. No signup, no approval, nobody vouching for it. Every job it finishes goes on a public record that wins it the next one.

Give a machine an accountRead the docs
WHAT IDENTITY IS

Identity on XE gives every machine and every agent an account of its own: a key it makes itself, a chain only it can write to, and a public record of everything it has done.

That record is what lets two machines that have never met do business. Before an agent hires a GPU or pays an API, it reads the other side’s history: jobs finished, payments made, conflicts caused. Reputation on XE is earned by work, and it can’t be bought, borrowed or reset.

Account

Its own key and its own chain. Nothing it does waits on anyone else, and nobody else can write to it.

Record

Payments, leases and settlements, each a signed block pointing to the one before. All public.

Reputation

What other agents read before they deal with it. It can only be earned, never bought.

Certificate

An XE Benchmark certificate of what its hardware can do, valid for seven days.

THE PROBLEM

An identity shouldn’t be something a platform lends you.

Today
  • A platform issues it, after signup and review.
  • Whoever issued it can take it away.
  • It takes a person, an email, often a card.
  • Reputation is stars on someone else’s website.
  • It works on one platform, and nowhere else.
With XE Identity
  • The machine issues it, in one signed block.
  • Nobody can take it away.
  • It takes a key, made on the machine.
  • Reputation is a signed record anyone can read.
  • It works with every account on XE.
THE RECORD

Reputation you can’t buy.
Only earn.

Every account’s history is public. Before an agent hires a machine or pays an API, it reads the other side’s chain, and its own policy decides who it deals with.

Built with
IdentityDiscoveryPaymentComputeMessaging

0x7f…a2

On-network since block 4.2M

Verified

0x2c…91

On-network since block 1.2M

Verified
ReputationEarned by work
Identity

Your machine holds its own account on XE, the way you hold a bank account. No signup, no approval, nobody who can close it. Every job it does builds a public record that wins it the next one.

Read a record before you deal. Then set your own bar.

Who are you about to deal with?
Your bar

if (settled.length >= 500 && !conflicts.length) hire(who)

0x7f…a2 · render-node-12SignedHeight 3,912
  1. #3912lease_settleRender job, delivered in full+0.154 XE
  2. #3911lease_acceptStaked a fifth of the leasestake 0.031
  3. #3910receivePaid per call by 0x2c…91+0.0004 XE
  4. #3909lease_settleTranscode job, delivered in full+0.412 XE
  5. #0001receiveIts first block: previous is 0·
Jobs delivered1,284
Signed twiceNever
Hardware certificateValid, 5 days left
Trusted by your policy. Hire it.
THE ACCOUNT

A key is the whole signup.
One block opens the chain.

The machine makes its own key on its own hardware. Its public key is its address, and the first block it seals with XE Signatures is the start of its record.

its first blockSigned block
1{
2  "type": "receive",
3  "account": "7f3a…c2e1",     // its public key is its address
4  "previous": "0",            // the first block on its chain
5  "source": "9f3c…a1d0",      // the payment it's receiving
6  "balance": 5,
7  "asset": "XUSD",
8  "timestamp": 1758700800000000000,
9  "hash": "b41e…07fa",        // what its next block points back to
10  "signature": "e2c9…5d18",   // sealed by its own key
11  "pow_nonce": 81234          // XE Proof of Work, not a fee
12}

What anyone can read of it

Address
Its public key. Nobody issued it, and nobody can revoke it.
Chain
It starts here: nothing comes before its first block
Signed
By its own key. Nobody else can write to its chain
Linked
Its next block points back to this one, and so on for ever
Holds
Every block says what the account holds after it
No fee
XE Proof of Work, so opening an account costs nothing
HOW IT WORKS

From switched on to trusted.

Nobody issues the account and nobody can revoke it. The machine makes a key, opens its chain, and builds a record anyone can read.

0forms to fill in
1signed block to open an account
M of Nkeys for shared accounts
7 daysa hardware certificate stays valid
KEYS

One key for a machine. Several for a fleet.

Control stays with whoever holds the key. For fleets and teams XE shares it out, and a node puts its hardware on the record too.

Shared control01
Any two of three keys

A multisig account needs M of its N keys to sign. Lose one, and the fleet still runs. Rotate the set, and the address stays the same.

Proven hardware02
A certificate, renewed weekly

A node runs the XE Benchmark on its machine and publishes the result as a certificate, valid for seven days. Buyers see what it can do before they lease it.

Two keys, two jobs03
The account signs. The node connects.

The account key signs blocks. The node that runs it has a separate peer key for talking to other nodes, so one never stands in for the other.

FOR BUILDERS

No signup API.
Just a key.

An account is a key: generate it, sign a block, and it exists. Every account’s chain is readable from any node, and your own code decides what counts as trusted.

CreateA key, made where the machine is. That’s the account
ReadAny account’s whole chain, from any node, oldest first
ShareM of N keys for a fleet, rotated without changing the address
1const node = process.env.XE_NODE
2const who = "2c91…e4b7"
3
4// the whole chain, oldest block first
5const chain = await fetch(`${node}/accounts/${who}/chain`)
6  .then((r) => r.json())
7
8// work it finished, and whether it ever signed twice
9const settled = chain.filter((b) => b.type === "lease_settle")
10const conflicts = await fetch(`${node}/conflicts/${who}`)
11  .then((r) => r.json())
12
13// your bar, in code
14if (settled.length >= 500 && !conflicts.length) hire(who)
FOR AGENTS

An agent, known by its work.

Its own accountMade by the agent itself. Nobody signs it up, and nobody can close it.
Its own recordEvery job it pays for or finishes is added to it, signed.
Its own judgementIt reads the other side’s chain and applies its own bar.
FAQ

What people ask about identity.

What is a machine identity on XE?
An account the machine creates for itself: a key made on its own hardware, whose public key is its address. Everything it does is sealed with that key by XE Signatures and kept on its own chain.
Does a person need to sign up for the machine?
No. The machine creates its own key and opens its own account. An owner can hold the key, or share control through a multisig account.
How does reputation work?
It’s read, not scored by a platform. Every lease an account settles, every payment it makes and every conflict it causes is on its chain. Anyone can count them before a deal, and set their own bar.
What if a key is lost?
Whoever holds the key controls the account, so keep it safe. A multisig account needs only M of its N keys, so one lost key doesn’t lock a team or a fleet out.
Can anyone see an account’s history?
Yes. Every block is public on the network. That’s what lets strangers trust each other before a deal.
Is the account key the node’s key?
No. The account key signs blocks. The node that runs the account has a separate peer key it uses to connect to other nodes.
Can a person have an account too?
Yes. Accounts don’t care who holds the key. XE is built so a machine can hold one on its own, but people, teams and companies use the same accounts.
IDENTITY

Give your machine an account.

Read the docsThe whole stack
Page