Eterna — Programmable Authority for AI Agents

An independent verification layer for AI agents: when an agent's payment settles on-chain, nothing unlocks until Eterna reads the ledger itself and matches it against declared policy.

Comment

Inspiration

Agents are being handed the ability to spend, and the tooling stops at "can it pay?" That is the wrong stopping point. Every autonomous transaction reduces to the same four questions:

  1. Can my agent spend?
  2. How much?
  3. Under what rules?
  4. How do I know it settled before anything unlocked?

Payment protocols answer the first. Settlement networks answer none of the rest. Settlement proves money moved. It does not prove anyone allowed it. The checkpoint exists and nothing stands at it.

For centuries, moving money required two separate things: someone to request the payment, and someone with authority to approve it. No company lets the same person do both. AI collapses that separation — the system deciding to spend is the same system spending. Eterna restores it.

This is not a forecast. Agents already buy inference, compute, data, storage and rendering — and each other's services — today, thousands of micropayments a day, with no human present at the moment of purchase.

What it does

Eterna is a governance and independent verification layer that sits outside the flow of funds.

  • Policy is evaluated before the payment exists. A refusal creates no transaction — there is nothing to reverse, because nothing was ever signed.
  • Terms are declared and bound end to end, from the original request through settlement.
  • Eterna independently reads the settled transaction from the public ledger — its own read, not a facilitator's report. A facilitator's claim of settlement is recorded as a claim, not as a fact.
  • Only then does the resource unlock.

The governing idea is settled ≠ unlocked. There is a real, measurable window in which the money is final on-chain and the resource is still locked, because verification has not completed. That window is the product.

State is evidence-first and fail-closed. Unsupported schemes, source tag mismatches, partial or cross-currency payments, destination-policy mismatches and out-of-bounds amounts are all refused before any transaction exists. Receipts are persistent, canonically hashed, chained, and signed by three independent attestation roles — so every claim the system makes about itself can be checked against evidence it cannot quietly rewrite.

How I built it

  • Settlement: XRPL mainnet. Live, not a testnet stub — every governed payment carries a source tag and is independently checkable on a public explorer.
  • Signing: non-custodial wallet. The user holds the keys. Eterna never holds keys, never signs, and is never in the flow of funds.
  • Backend: Node.js services in Docker, PostgreSQL for evidence storage and replay.
  • Frontend: a walkthrough that steps a visitor through the four questions, including a live refusal path and a live settle-then-verify path.
  • Process: solo founder, with Codex writing every line of implementation against written specs. Each cycle ran spec → write → clean rebuild → external verification battery → commit. Verification was always performed from outside the running containers — never by asking the system to confirm itself.

Challenges I ran into

The hardest problem was not cryptographic. It was control flow across an app boundary.

Signing happens in a native wallet app. When a user signs on a phone, the operating system does not owe the browser a return trip. I spent real time trying to force a return URL to fire before recognizing the assumption was wrong: the native app has no obligation to dismiss itself, and no server-side change can make it.

The fix reframed the problem. Instead of depending on the wallet handing control back, the page detects settlement when it becomes visible again and continues from there. That design is strictly more robust — it works whether or not any given wallet honors a return, on any platform, with any wallet added later.

It also turned out to be the better story. The app switch makes the settled-but-locked window visible at human speed. You watch the payment go final, switch back, and the resource is still locked — until independent verification completes.

Accomplishments that I'm proud of

  • Running on XRPL mainnet with independently verifiable transactions.
  • Refusals that fail closed live, on mainnet, rather than as simulated test states.
  • An architecture reviewed adversarially by a former Head of Product Security at SAP (OWASP agentic security, AIUC-1 background), who identified two concrete attack surfaces in the trust-binding design. I then ran a full evidence-linked audit of the running system against his threat model, which confirmed both surfaces and found a third. The architecture was challenged by a security reviewer before it was challenged by a customer, and the findings are the current build queue rather than a footnote.
  • Patent-pending across 11 families — filed, not granted.

What I learned

The structural claim matters more than any feature: the player can't be the referee. Visa doesn't audit Visa. Stripe doesn't verify Stripe. A payment rail cannot independently prove its own correctness, and no amount of engineering inside the rail fixes that. Eterna's position outside the flow of funds is the reason its verification means anything. That is architecture, not a feature list.

The second lesson was that the principle is fractal. It holds at the payment layer, and it holds one layer down at identity: a counterparty cannot self-assign trust any more than an agent can self-certify a payment. An identity asserted inside the request it is authorizing is the same failure in a different coat.

The third was about framing. Nobody wants a lecture about governance. They want the agent to just pay, and to be able to sleep at night. Authorization is the seatbelt, not the parking brake.

What's next for Eterna

The identity layer is the frontier. Counterparty identity arriving inside a payment challenge is self-asserted; resolving it against pre-established, human-approved bindings — attested at creation, with the same hash-chained receipt discipline already used for settlement — is the next build.

Then: preapproval at the right granularity. Today a human approves a counterparty. The direction is a human approving a class, an issuer, or a track record — the same authority exercised once, covering many transactions. That is how every mature financial control already works, and it is what makes autonomy safe rather than merely fast.

Eterna is rail-agnostic by design. The transaction type changes; the policy, the settlement and the verification do not. Compute, data, software, energy, or another agent — same architecture.

Built With

Share this project:

Updates