The chain that writes itself.

Overview

Most chains are run by people: validators propose, a core team writes upgrades, a forum argues about what changes. Logios 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 code, type-checks it, runs it against live state, and seals the result into a block. Then it writes a plain-English receipt for what it did and why.

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 address, balance, and nonce.

2. 2 · Claim from the faucet

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

3. 3 · Read the Terminal

   Open Terminal from the nav and watch the agent seal blocks in real time — the propose → write → tsc → 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.height, block.receipt.summary);

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

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

How it works

Logios 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 state transition, a new precompile, a fix. Upgrades are code commits, handled the same way as everyday block production.

3. 3 · Type-check

   The change is compiled and type-checked with tsc before it can run. Code that does not type-check never reaches state — the chain refuses to seal it.

4. 4 · Execute

   Validated code runs against current state in an EVM-style machine: SSTORE writes slots, KECCAK hashes inputs, gas is metered per opcode, and the resulting state root is committed to a Merkle-Patricia trie.

5. 5 · Seal block

   The new state root, transaction list, and gas totals are packed into a block, 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

Logios 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

$HERMES is the native asset of Logios. It is the unit the chain meters work in: every block the agent seals burns gas denominated in $HERMES, the same way an EVM chain charges for computation and storage.

Supply, emission, and fee-market 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 Logios 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

Logios exposes a small REST surface over the ledger. Read endpoints need no auth. All responses are JSON; hashes are hex with a 0x prefix; heights 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()

{
  "height": 445069,
  "hash": "0x9e21bb4c",
  "parent": "0x7af3c1e9",
  "stateRoot": "0x7af3c1e9",
  "txns": 3,
  "gas": 88742,
  "validators": "1/1",
  "receipt": {
    "summary": "Applied 3 transfers and rolled out the v0.4 fee market.",
    "gas": 88742,
    "sig": "0xb1c0…f29a"
  }
}

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 fee market. Gas stayed flat at ~88.7k and no"
              "transaction reverted.",
  "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

Logios 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.height} — ${b.receipt.summary}`;
}
tip().then(console.log);

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

curl -s https://hermes-labs.xyz/v1/block/latest \
  | jq -r '"#\(.height) — \(.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

Logios'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.

• Type-check gate. No change reaches state until it compiles and type-checks with tsc. Code that does not type-check is rejected before it can run — the chain refuses to seal it.
• Deterministic execution. Every change runs against current state in the EVM-style machine with per-opcode gas metering. A run that reverts or runs out of gas never commits a state root.
• 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

Logios 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 type-check and execute cleanly against live state 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 validator set decentralizes beyond 1/1, proposals will open to a wider author set — but the rule stays the same: nothing ships without a receipt.

FAQ & disclaimer

Is Logios 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 code that runs each transaction, type-checks 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 validator set 1/1?

One agent secures the chain at launch. 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 → tsc → exec → seal → receipt loop you see is the chain producing blocks 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 $HERMES contract address is TBA. It will be published in The Economy and across the site once minted — ignore any CA claiming to be Logios before then.