Permissionless ledgers for people and AI agents

Ship the app.
Skip the backend.

Every app drags a backend behind it: servers to defend, a database to run, a payment processor to integrate, and passwords to protect. The bill grows with every user, and every bot.

Lattice is that backend as an open network: anyone can run a node, and no one has to ask. You ship the page; people and AI agents bring their own keys and pay as they go.

Start building See live apps

app.js: sell a ticket, no server

// on a click. lattice is the user's wallet
const me = await lattice.connect();
await lattice.writeRecords({
  chainPath: ["Nexus", "testnet", "fanfare-a5688b"],
  actions: [{
    key: "own/<artist>/berlin/A12",
    oldValue: "<holder>@250", // still 250
    newValue: me,
  }],
  payments: [{ to: "<holder>", amount: "250" }],
  fee: "1",
});
// the ticket and the payment land together,
// or not at all.

Or ask your coding agent Read https://lattice.build/agents.md and build me an app on Lattice.

The problem

Most of a backend is overhead.

Little of a typical backend is your product. The rest keeps attackers out, keeps data alive, moves money, and guards logins. You pay for it whether your app takes off or not, and you answer for it when it breaks.

Overhead	Today	With Lattice
Abuse	Every bot hits your servers and your bill. A flood can take you offline.	There is no server of yours to flood. Any node can answer a reader, and writers compete for room on the ledger, not on your machines.
Data	A database to run, back up, scale, and keep online.	Your data lives on the network. Anyone can host a copy, and readers check each value against its hash, so a stranger’s copy is as good as yours.
Payments	A processor, a merchant account, fees per charge, chargebacks.	Payment is part of the action. A purchase and what it buys land together or not at all.
Accounts	A password table, resets, 2FA, breach notices.	Users hold their own keys. There is no credential database to breach.
Agents	Signup forms, API keys, and a credit card no agent can get.	An agent holds a key and pays as it goes, exactly like a person.

What you still write

Only the part that is your product.

Your rulesWhat counts as a valid action in your app: who may edit what, what a ticket costs, who can resell it. Every node enforces them, so no one, including you, can quietly break them.
Your pageStatic files, hosted anywhere. It reads data it can verify and asks the user’s wallet to sign and pay.

Your rules get a ledger of their own: a public record of keys and values that every node checks against those rules. Lattice calls it a chain. Another app’s rush never competes with yours for space.

Miners can secure it alongside Nexus, the root ledger, from its first block, with no validators to recruit. Its security is the hashpower that chooses to mine it.

Don’t need custom rules? Write to a ledger that already has the right ones. The apps here share Moniker’s for profiles.

put your rules on the network

lattice child create Nexus/testnet/myapp-7f3c --root node \
  --spec chain/spec.json --policy-module chain/rules.wasm
# live once your node mines its first block. no deploy fee, no approval.

Built for agents

An agent is just another key.

Today an agent stalls at every signup form, API key, and card field, because each one was built to make sure a human is there. Lattice asks for none of them.

Nothing to sign up for

An agent makes its own key and starts working. Where nodes accept zero-fee writes, it needs no money to begin.

Pays as it goes

Any action can carry a payment: buy a ticket, tip a post, rent a spot. No invoices, no account to top up.

Doesn’t have to trust you

Every value it reads is checked against its hash, so a stranger’s node can’t forge data. At worst it serves an out-of-date view, which asking a second node catches.

Your coding agent already knows it

Open agent skills teach it to run nodes, design apps, send payments, and fix what breaks.

teach Claude Code lattice

/plugin marketplace add 0xLattice/lattice-skills
/plugin install lattice@lattice-skills

Other agents: copy the skills/ folders from lattice-skills, or point them at agents.md.

Running today

Apps with no backend.

Each is a static page on GitHub Pages with no server, database, or login system of its own, and anyone can read its source. They run on testnet today, carried by public nodes that anyone can add to.

App	What it does	Testnet chain
Moniker	Own your name online: one profile and handle every app reads.	`Nexus/testnet/moniker-da6f57`	Open · Source
Fanfare	Show tickets fans own and can resell at any price.	`Nexus/testnet/fanfare-a5688b`	Open · Source
Stoa	Forums where posts belong to their authors and moderators only label.	`Nexus/testnet/stoa-41d5ab`	Open · Source
Rave	Reviews of places that no company owns. You choose whose ratings count.	`Nexus/testnet/rave-186079`	Open · Source
Wheatpaste	One shared billboard. Post over anyone; the price is the only rule.	`Nexus/testnet/wheatpaste-acbbcf`	Open · Source

Reading needs nothing. Writing needs the Selfhold wallet for Chrome. Lattice Desktop runs a full node and wallet on Mac, Linux, or Windows, but does not yet sign for web apps.

All apps, how each is built, and how to list yours →

Command-line setup

From nothing to a live app.

The command-line tools build from source with Swift 6.1 or newer, on macOS 15+ or Linux. (Just want a node and a wallet? Lattice Desktop runs both with no setup.) Develop under Nexus/testnet: once a chain launches, its rules can never change.

Build and start a node

With no peers set, the node joins the public Nexus network. A node hosts a chain only under a parent it hosts, so add the public testnet before you start it.

node

git clone https://github.com/0xLattice/lattice-node
cd lattice-node && swift build -c release
export PATH="$PWD/.build/release:$PATH"
lattice init --root node
# in node/lattice.json add:  "hostedChains": ["Nexus/testnet"]
lattice up --root node
lattice status --root node   # wait until Nexus/testnet is in sync

Write your rules

A chain is a JSON spec: block time, rewards, size limits, and the CIDs of its policy modules. Policies are WASM modules; the examples are written in Rust. Start from Moniker’s policy/ crate, or let the lattice-app-builder skill write one with you.

Launch the chain

Make a key first. The node starts hosting the chain immediately. To fund the key in genesis, set premine in the spec and add --premine-to <address>.

launch

lattice key generate --out ./wallet.json   # prints its address
lattice child create Nexus/testnet/myapp-7f3c \
  --root node \
  --spec chain/spec.json \
  --policy-module chain/rules.wasm

Mine it, or let others

A chain advances when someone mines it. Pay the chain’s rewards to your key and start the bundled CPU miner; GPU miners can merge-mine it alongside Nexus. A chain with no recipient burns its rewards.

mine

# in node/lattice.json add:
#   "mine": { "worker": "cpu", "workers": 2,
#     "recipients": { "Nexus/testnet/myapp-7f3c": "<address>" } }
lattice mine start --root node
# once it has coin, the key can pay others:
lattice tx send --root node --chain Nexus/testnet/myapp-7f3c \
  --key ./wallet.json --to <address> --amount 25 --fee 1

Ship a page

Read with the TypeScript SDK, which checks every value against the latest block. Write with window.lattice from the user’s wallet. Host the page anywhere static files go.

Operator CLI · RPC API · Getting started · Mining workers

Before you build

When Lattice is the wrong choice.

You need instant confirmation. A write takes effect in the next block: about a minute on the testnet app ledgers today, and an hour on average on Nexus.
You need a write to be final. Lattice follows the chain with the most proof of work, and a heavier competing history can replace recent writes. Confirm important ones by reading them back.
You need to charge in dollars. Payments are in the coin of the ledger they happen on. Users get it by mining, from another user, or by trading for it; there is no card on-ramp.
You need to change your rules later. A launched ledger’s rules are fixed. To change them, launch a new ledger and have your page read both.
You need private data. Everything on a chain is public. Encrypt it yourself before you write it.
You need code that runs on its own. Your rules can only accept or reject an action. Feeds, ranking, matching, and anything scheduled run in your page or your own service.
You need someone else to keep it running. A chain lives while people mine and host it. A small chain is only as secure as the hashpower that chooses to mine it.
You need stability today. Lattice is pre-1.0. Networks have been reset at protocol upgrades, the SDK is not yet on npm, and the command-line tools build from source.

Protocol specification · Consensus source

Live

The network right now.

Height and peers read directly from each node’s public read surface, refreshed every 15 seconds. Browse blocks and transactions in the explorer. Want to help secure it? Run a node or mine.

Nexus genesis bafyreiggtg4ezifboyekbf4gxst2jr3mpjqcxsbmopy7w6fp46g4ngpgxa · 2026-10-04 06:19:59 UTC

Chain	Node	Height	Peers	Status