The chain that writes itself.

Overview

Most chains are run by people: stakers propose, a core team writes upgrades, a forum argues about what changes. Hermes Labs cuts the people out. One agent does the work, out loud, on screen, no dashboard summarizing it after the fact.

Every block is authored by the agent, not just validated. When the chain needs a new feature, the agent proposes the change, writes the program, compiles it, runs it against live accounts, and seals the result into a slot. Then it writes a plain-English receipt for what it did and why. $LABS is an SPL token on Solana, launched on pump.fun.

Quickstart

There are two ways in. If you just want to watch the chain think, everything is on the homepage as a live overlay — no install, no SDK. If you want data, the read API is one fetch away.

From the browser

1. 1 · Connect a wallet

   On the homepage, open Wallet (the APP button, top-right) and connect. You'll see your base58 pubkey and SOL plus $LABS balance.

2. 2 · Claim from the faucet

   Open Faucet from the stat-bar, paste your address, and drip test tLABS. There's a short cooldown between claims.

3. 3 · Read the Terminal

   Open Terminal from the nav and watch the agent seal slots in real time — the propose → write → build → exec → seal → receipt loop, streaming live.

4. 4 · Explore a block

   Open Explorer, pick a recent block, and run Explain last block to have the agent narrate exactly what the chain just did, in plain English.

From code

Read the latest block over the public REST API. No auth for read endpoints.

curl https://hermes-labs.xyz/v1/block/latest

const res = await fetch("https://hermes-labs.xyz/v1/block/latest");
const block = await res.json();
console.log(block.slot, block.receipt.summary);

import requests
block = requests.get("https://hermes-labs.xyz/v1/block/latest").json()
print(block["slot"], block["receipt"]["summary"])

That's the live read API. The full endpoint list is in API Reference.

How it works

Hermes runs a single repeating loop. Each pass produces exactly one block and one receipt. There's no mempool of competing proposers and nobody signing off between steps. The agent owns the whole cycle.

1. 1 · Propose

   The agent decides what the chain should do next — apply pending transactions, patch a bug, or ship a protocol upgrade — and drafts an intent for the block.

2. 2 · Write code

   It writes the actual changes: a Rust/Anchor program, a new instruction, a fix. Upgrades are code commits, handled the same way as everyday slot production.

3. 3 · Build

   The change is compiled with cargo build-sbf and its constraints checked by anchor test before it can run. A program that does not compile never reaches the accounts — the chain refuses to seal it.

4. 4 · Execute

   Validated programs run against current accounts in the SVM (Sealevel) runtime: programs read and write accounts, compute is metered in compute units against the compute budget, and the updated account state it touched is committed.

5. 5 · Seal slot

   The updated accounts, transaction list, and compute-unit totals are packed into a slot, hashed, and appended to the chain.

6. 6 · Write receipt

   An LLM narrates the block into a plain-English receipt — what changed, why, and what it cost — and stores it next to the block so anyone can read the chain's reasoning, not just its bytes.

Anatomy of a sealed block

A trimmed trace of one loop, as the Terminal shows it:

The same stream is visible live on the homepage Terminal — this is not a render of stored logs, it is the agent working.

The Stack

Hermes Labs is five cooperating layers. The agent runtime drives the loop; everything below it exists to execute, record, and expose what the agent decides.

The Terminal and Explorer ship on the homepage as live overlays. The same ledger that powers the Explorer is exposed over REST — see API Reference.

The Economy

$LABS is an SPL token on Solana, launched on pump.fun. It is the unit the chain meters work in: every slot the agent seals spends compute units against the compute budget, and priority is paid in lamports — how Solana charges for computation and account writes.

Supply, emission, and priority-fee parameters are themselves under the agent's stewardship — any change ships as a receipted upgrade you can read in the ledger.

Receipts & Ledger

The ledger is an append-only chain of blocks. What makes Hermes Labs different is the receipt: a signed, plain-English record attached to every block, written by the agent the moment it seals. The bytes say what the state became; the receipt says why.

The receipt isn't written after the fact. It's produced inside the same loop as the block, signed with the same key, stored next to it. You can read the chain's reasoning the way you read its balances.

Anatomy of a receipt

Pull recent receipts from GET /v1/receipts — see API Reference. The reasoning is permanent. It can't drift from the code, because it's committed with it.

API Reference

Hermes Labs exposes a small REST surface over the ledger. Read endpoints need no auth. All responses are JSON; hashes and signatures are base58; slots are integers. The base URL is https://hermes-labs.xyz.

GET /v1/block/latest

Returns the newest sealed block. The receipt is embedded so a single round-trip gives you both the bytes and the reasoning.

curl -s https://hermes-labs.xyz/v1/block/latest | jq .

const r = await fetch("https://hermes-labs.xyz/v1/block/latest");
if (!r.ok) throw new Error(`logios ${r.status}`);
const block = await r.json();

import requests
r = requests.get("https://hermes-labs.xyz/v1/block/latest", timeout=10)
r.raise_for_status()
block = r.json()

{
  "slot": 445069,
  "blockhash": "9eK2bB4cT7vQ1mNqR8sWfYxZ3dGhJ5pLnV6uA2cE9rD",
  "parent_slot": 445068,
  "transactions": 3,
  "compute_units": 88742,
  "leader": "self",
  "receipt": {
    "summary": "Applied 3 transfers and rolled out the v0.4 priority-fee curve.",
    "compute_units": 88742,
    "signature": "5h7Kq…f29aZ8mPwR3sT1xN6bV4cL9dG2uJ8eA5rQ7yW3kF6nH4pS"
  }
}

POST /v1/explain

Hand the agent a block reference and get back a narration — the same ritual the Explorer's Explain last block runs.

curl -X POST https://hermes-labs.xyz/v1/explain \
  -H "content-type: application/json" \
  -d '{"block":"latest"}'

const r = await fetch("https://hermes-labs.xyz/v1/explain", {
  method: "POST",
  headers: { "content-type": "application/json" },
  body: JSON.stringify({ block: "latest" }),
});
const { narration } = await r.json();

import requests
r = requests.post(
    "https://hermes-labs.xyz/v1/explain",
    json={"block": "latest"},
)
print(r.json()["narration"])

{
  "block": 445069,
  "narration": "The agent applied three token transfers and shipped"
              "the v0.4 priority-fee curve. Compute stayed flat at ~88.7k CU"
              "and no transaction failed.",
  "model": "logios-narrator"
}

These endpoints are live, but the payloads are still experimental and can change while the protocol is young. Breaking changes ship as receipted upgrades you can read in the ledger.

Agents

Hermes Labs is meant to be read by machines first. Anything a human sees on screen has a JSON twin an agent can parse. You read the chain as data, never as a screenshot.

Discover the chain from one file

An agent bootstraps by reading the descriptor, then follows the endpoints it advertises:

# 1. read the machine-readable descriptor
curl -s https://hermes-labs.xyz/.well-known/hermes-logios.json
# 2. read the LLM brief
curl -s https://hermes-labs.xyz/llms.txt

// bootstrap: descriptor → endpoints → latest state
const desc = await (
  await fetch("https://hermes-labs.xyz/.well-known/hermes-logios.json")
).json();
const latest = await (await fetch(desc.endpoints.latestBlock)).json();
console.log(latest.receipt.summary);

import requests
desc = requests.get(
    "https://hermes-labs.xyz/.well-known/hermes-logios.json"
).json()
latest = requests.get(desc["endpoints"]["latestBlock"]).json()
print(latest["receipt"]["summary"])

The agent-native files (/llms.txt, /.well-known/hermes-logios.json) ship alongside the site so any model can find its way around the chain on its own.

Examples

Copy-paste recipes for the three things people do most: read the tip of the chain, ask the agent to explain a block, and check what it's doing right now.

Fetch the latest block

async function tip() {
  const r = await fetch("https://hermes-labs.xyz/v1/block/latest");
  const b = await r.json();
  return `#${b.slot} — ${b.receipt.summary}`;
}
tip().then(console.log);

import requests
b = requests.get("https://hermes-labs.xyz/v1/block/latest").json()
print(f"#{b['slot']} — {b['receipt']['summary']}")

curl -s https://hermes-labs.xyz/v1/block/latest \
  | jq -r '"#\(.slot) — \(.receipt.summary)"'

Explain a block

const r = await fetch("https://hermes-labs.xyz/v1/explain", {
  method: "POST",
  headers: { "content-type": "application/json" },
  body: JSON.stringify({ block: 445069 }),
});
console.log((await r.json()).narration);

import requests
r = requests.post(
    "https://hermes-labs.xyz/v1/explain",
    json={"block": 445069},
)
print(r.json()["narration"])

curl -s -X POST https://hermes-labs.xyz/v1/explain \
  -H "content-type: application/json" \
  -d '{"block":445069}' | jq -r .narration

Check the agent

// is the chain WORKING or STANDBY right now?
const r = await fetch("https://hermes-labs.xyz/v1/agent");
const { state, task } = await r.json();
console.log(state, task);

import requests
a = requests.get("https://hermes-labs.xyz/v1/agent").json()
print(a["state"], a["task"])

curl -s https://hermes-labs.xyz/v1/agent \
  | jq -r '"\(.state) — \(.task)"'

The Terminal, Explorer, and Faucet also open as overlays on the homepage — bookmark it and you have the whole chain in one tab.

Security

Hermes Labs's security model follows from its design: if the agent authors everything, the safeguards have to live inside the loop, not in a review process bolted on afterward.

• Build gate. No change reaches the accounts until it compiles with cargo build-sbf and its constraints hold under anchor test. A program that does not build is rejected before it can run — the chain refuses to seal it.
• Deterministic execution. Every change runs against current accounts in the SVM (Sealevel) runtime, metered in compute units against the compute budget. A run that fails or exhausts its compute budget never commits account state.
• Signed receipts. Each block's receipt is signed by the authoring agent. Tampering with the reasoning breaks the signature, so the record can't be quietly rewritten.
• Append-only ledger. History is immutable — blocks chain by parent hash, and the Explorer lets anyone replay a decision from genesis.
• Public by default. There is no privileged backend that sees more than the Terminal does; the attack surface is the surface you can read.

Governance

Hermes Labs governs itself the way it produces blocks: every change is proposed, executed, and receipted in the open. There is no off-chain forum where decisions are made and then quietly applied — the proposal is the work, and the receipt is the record.

• Proposal. The agent drafts an upgrade as a code change with a stated rationale — the same intent that opens a block.
• Validation. The change must build and execute cleanly against live accounts before it can be sealed; a failing upgrade is rejected automatically.
• Receipt. Once shipped, the upgrade leaves a signed, human-readable receipt in the ledger: what changed, why, and what it cost.
• Audit. Anyone can replay the decision in the Explorer — the full reasoning is permanent, not a summary that can drift from the code.

As the author set decentralizes beyond a single leader, proposals will open to a wider author set — but the rule stays the same: nothing ships without a receipt.

FAQ & disclaimer

Is Hermes Labs a real, settled blockchain?

No. It's an experimental, agent-authored chain running in the open. Treat it as a prototype, not a settlement layer.

What does "the chain that writes itself" actually mean?

The agent writes the program that runs each transaction, builds it, executes it, and ships its own protocol upgrades. So the chain's history is also the history of its own development.

Why is the leader just self?

One agent secures the chain at launch as the single autonomous leader. That keeps the loop easy to follow while the protocol is young. Adding more authors is tracked in Governance.

Is the Terminal real or a replay?

Real. The propose → write → build → exec → seal → receipt loop you see is the chain producing slots as you watch, not a recording.

Is there an API I can build on?

Yes, a small REST surface over the ledger. See API Reference for endpoints and Agents for the machine-readable descriptor and /llms.txt. The endpoints are live; payloads can still shift while the protocol stabilizes.

Where is the token contract?

The $LABS contract address is Gpm3ntMpi6g92W1Qgo2FxXeFXF1rM8f9pb85u2ZEpump, launched on pump.fun. It is also shown in The Economy and in the top bar across the site — ignore any other CA claiming to be Hermes Labs.