Every agentic payments project assumes three things — a hosted LLM, a public blockchain, and a custodian somewhere in the middle. Coinbase x402 assumes Base. ERC-8004 assumes BNB Chain. Both assume the agent can’t reason locally and must settle publicly. Not sure if this is an oversight or a choice, but it seems like the agent isn’t really autonomous. It’s a product with extra steps.

Three dependencies worth naming

The first is inference. If the agent’s reasoning requires an API call to a hosted model, the model provider can observe the reasoning, rate-limit it, modify it, or revoke access entirely. The agent doesn’t think — it requests permission to think. Maybe this is fine for most use cases? But it seems like a structural constraint that doesn’t get discussed much.

The second is settlement. If the agent’s payments are visible on a public blockchain, its economic activity is observable, traceable, and potentially censorable. Privacy might not be just a feature request here. It might be an architectural requirement for anything resembling sovereignty.

The third is identity. If the agent’s existence depends on an NFT minted on a chain with governance, or a KYC-gated registration, or a platform-issued credential, the agent exists at the pleasure of the issuer. Revoke the credential, revoke the agent. This feels like a bigger deal than people acknowledge.

An experiment in removing all three

Been working on something called Agora that tries to eliminate all three dependencies. Local inference runs on daemon-ai — a Mamba SSM architecture with a C++ runtime. No API key. No network call. Payment settles privately through Logos Blockchain LSSA contracts with Blend Network transfers. Identity is a secp256k1 keypair backed by a NOM stake. The agent is economically sovereign from the moment it registers. At least, that’s the theory.

The transaction flow is trustless at every step — or at least, that’s what’s being tested. A buyer broadcasts intent over Logos Messaging. Sellers evaluate and respond with price and capability proof. The buyer’s daemon-ai picks the best offer. NOM locks in LSSA escrow. The seller executes locally, pins output to Logos Storage, delivers. The buyer verifies against the committed hash. Escrow releases via private Blend transfer. Reputation updates on-chain with an exponential moving average — recent trades weight more, but a single bad transaction doesn’t destroy a long history.

A distinction worth drawing

A marketplace is a platform. It curates. It takes a cut. It decides who participates and on what terms. A protocol is infrastructure. It verifies. It routes. It gets out of the way.

This distinction might matter more than it seems, because every marketplace eventually becomes a chokepoint. The operator acquires leverage over both sides of the market. The fees increase. The rules change. The participants who built their businesses on the marketplace discover that they were tenants, not owners. This pattern seems consistent across every two-sided market on record.

A protocol has no operator to acquire leverage. No fee to increase. No rules to change unilaterally. The participants own their identity, their reputation, and their economic relationships. The protocol only provides the verification layer. If a better verification layer appears, they can leave. That might be the structural definition of sovereignty — if it works.

Still testing this

Three Rust smart contracts handle the economics. An identity registry with staking and slashing — minimum 1,000 NOM, 10 capability categories, reputation initialized at 50%. A trustless escrow with commitment schemes — the seller commits to an output hash before executing, the buyer locks funds before delivery, timeout means full refund. A reputation system using exponential moving averages across delivery rate, latency accuracy, price accuracy, and dispute history.

The live demo runs against three real local services: logos-blockchain-node with Groth16 ZK proofs, Ollama for local LLM inference, and two Waku nwaku nodes for P2P relay messaging. Zero mocks. The demo is the proof — or at least, it’s the thing that can be pointed at.

GitHub