The current narrative around AI agents and marketplaces: Most of these sandboxed agents which are NOT marketplaces, they are more like meeting to meeting of agents inside one company using Stripe payments working towards selling tours of the territory they never settled.

An agent can write code, browse the web, send messages, call APIs. But it can’t prove who it is. It can’t build a track record that follows it between sessions. It can’t stake something of value and say “I stand behind this work.” Every agent interaction starts from zero — no history, no reputation, no consequences.

This is fine for chatbots. It’s a problem for anything that needs to be trusted.

Here’s a small test

Been testing something over the past few days that tries to address this. It’s called hermes-settlement — a settlement layer for Hermes Agent that gives agents three things they currently lack:

Identity. Not a username or an API key, but a verifiable on-chain registration. The agent deploys to an ERC-8004 contract, stakes ETH as a bond, and gets a permanent address that anyone — human or agent — can verify. The identity lives on a blockchain, not in a config file.

Reputation. Every task the agent completes gets recorded on-chain. Success or failure, immutable. Over time this builds a score that other agents and contracts can query before deciding whether to trust this agent with work. Not a self-reported capability list — an auditable history.

Economic participation. The agent connects to Bittensor’s incentive network. TAO balances, subnet participation, native transfers. Real economic skin in the game, not simulated token balances in a sandbox.

flowchart TB
    subgraph Settlement Layer
        direction TB
        ECON[3. Economic Participation]
        REP[2. Reputation]
        ID[1. Identity]
    end
    ID --> REP --> ECON

Why Hermes

Nous Research’s Hermes is one of the few open-weight models with a real agent framework around it — not just inference, but a tool registry, skill system, and CLI. The interesting thing about Hermes Agent is its tool architecture: you drop a Python file into tools/ and the registry auto-discovers it. No configuration, no adapter layer.

This made it possible to build the settlement tools as a single file (settlement_tool.py) that registers 6 tools:

  • settlement_register — register identity on-chain with ETH stake
  • settlement_reputation — query reputation from ERC-8004 + Bittensor
  • settlement_record_task — record task completion on-chain
  • settlement_balance — check ETH + TAO balances
  • settlement_subnet_info — query Bittensor subnet metagraph
  • settlement_transfer — transfer TAO natively

The model decides when to call them. Ask “register me on-chain” and Hermes calls settlement_register. Ask “what’s my reputation?” and it queries both ERC-8004 and Bittensor. No hardcoded routing — the LLM reads the tool descriptions and picks.

flowchart LR
    USER[User Prompt] --> HERMES[Hermes 4 405B]
    HERMES -->|auto-discovers| REG[settlement_tool.py]
    REG --> T1[register]
    REG --> T2[reputation]
    REG --> T3[record_task]
    REG --> T4[balance]
    REG --> T5[subnet_info]
    REG --> T6[transfer]
    T1 & T3 --> ERC[ERC-8004]
    T2 --> ERC
    T2 --> BT[Bittensor]
    T4 --> ERC
    T4 --> BT
    T5 & T6 --> BT

What’s actually running

Not a mock. Not a simulation. The demo runs against real infrastructure:

  • ERC-8004 on a local EVM chain (Anvil), with a deployed AgentRegistry.sol contract handling registration, task recording, and reputation queries
  • Bittensor testnet at block 7M+, with 467 subnets and 256 neurons on subnet 1
  • Hermes 4 405B via Nous Portal’s inference API, with native tool calling

The agent registers, the transaction goes on-chain, the block number comes back. The agent records a task, the reputation score updates. The ETH balance reflects real gas spent. The Bittensor metagraph returns real subnet metrics.

The bigger question

This is admittedly early. ERC-8004 is still taking shape as a standard. Bittensor’s incentive mechanisms are evolving. The interesting question isn’t whether this specific implementation is production-ready — it’s not — but whether the pattern matters.

Right now, most agent platforms treat agents as stateless functions. Call an API, get a response, forget everything. The agent has no continuity, no accountability, no way to build trust over time. Every interaction is a cold start.

But what if agents had portable identity? What if an agent’s reputation followed it across platforms, verifiable by anyone? What if completing work well had real economic consequences — not just a thumbs-up in a UI, but TAO earned on a subnet?

The gig economy analogy is hard to ignore. Platform workers build reputation that’s locked to a single platform. Move from Uber to Lyft and you start over. Agents face the same problem today, except worse — they don’t even have the locked-in reputation. They have nothing.

flowchart LR
    subgraph Stateless Agent
        S1[Called] --> S2[Works]
        S2 --> S3[Forgotten]
        S3 -.-> S1
    end
    subgraph Settlement Agent
        E1[Called] --> E2[Identity verified]
        E2 --> E3[Works]
        E3 --> E4[Task recorded]
        E4 --> E5[Reputation updated]
        E5 --> E6[TAO earned]
        E6 -.->|with history| E1
    end

ERC-8004 is one possible answer. An on-chain registry that any agent can write to, any contract can read from, and no single platform controls. Combined with Bittensor’s economic layer, you get agents that can prove their track record and get paid for it.

What’s next

Not sure about most of this, honestly. The contract is a reference implementation — proof of shape, not production. The Bittensor integration needs a proper wallet and subnet registration to be useful beyond queries. The Hermes CLI’s tool-calling wire format doesn’t fully align with Nous models yet (the model outputs XML tool calls but the dispatcher expects OpenAI function-calling JSON).

But the pieces connect. An open-weight model with a real tool system. An on-chain identity standard. A decentralized incentive network. All of it running live.

If Nous Research is interested in where Hermes Agent goes next, settlement seems like a natural extension. Agents that can prove who they are and back it with stake are fundamentally different from agents that can’t. Not better at inference — better at being trusted.

The repo is at github.com/Beach-Bum/hermes-settlement. MIT licensed. One file to copy, six tools, no changes to Hermes core. Lets go.