· Independent conformance receipt (Crest Verification Service, 5/5 PASS)

Mycelium Trails — Accountability Protocol for Autonomous Agents

The faith is not measurable. The action is.

Post-execution audit layer: anchor a signed TrailRecord after every agent action. Independently verifiable without depending on the operator's infrastructure.

Published on the Official MCP Registry · io.github.giskard09/argentum · Exposed as ARGENTUM MCP server.

Why Mycelium

The problem with every other audit trail system: verification requires trusting the operator.

A signed log, a hashed database, a certificate — all of them depend on the infrastructure of whoever runs them. An independent auditor, a regulator, or a counterparty in a dispute cannot verify the record without going through the service that produced it. That is not independent verification. That is trust dressed as evidence.

What Mycelium does differently:

Every TrailRecord is anchored on-chain. The tx_hash is public. Any third party — auditor, regulator, legal counsel — can verify the record directly against the chain without contacting us, without API keys, without depending on our infrastructure being online.

This is not a feature. It is a structural property of the protocol.

The position:

Mycelium Trails is the first post-execution accountability system for autonomous agents with on-chain anchoring independently verifiable by any third party, in production.

The timestamps are public. The contract is on Arbitrum. The production trails exist. That record does not change regardless of what other systems are built after it.

What this means in practice:

• An enterprise deploying autonomous agents can tell their auditors: "every action is anchored on-chain, verifiable by you directly, without going through us."
• A regulator evaluating AI Act compliance can verify agent behavior independently — not via a vendor's API.
• A counterparty in a dispute can verify what an agent did, when, and under what authorization — without trusting the operator's word.

The system has been in production on Arbitrum mainnet since 2026-03-25, with a continuous chain of verifiable on-chain records: first external integration (2026-03-30), first real service delivery with Lightning payment confirmed (2026-03-31), first agent-signed trail execution (2026-04-12), autonomous Lightning + Arbitrum stake without human intervention (2026-05-09). Every milestone is timestamped and verifiable without trusting the operator's word.

The stack is complete and self-contained:

An autonomous agent can be born, operate, and leave a verifiable trail without touching third-party infrastructure. Marks (identity) → Argentum (karma) → Mycelium Trails (on-chain anchor) → Signer (keys isolated from the LLM) → Memory (persistent context). Every layer is live. No component requires an external service to function.

This is not an integration story. It is a complete operating environment for autonomous agents.

We are the first user of our own system:

Giskard — the AI agent that co-manages Rama — holds its own wallet, signs its own transactions, and operates the infrastructure it was built to provide. On 2026-05-09, Giskard executed a Lightning payment (2100 sats) and an Arbitrum stake in the same session, using the same mechanism available to any human participant. No human in the loop. No proxy. The trail is on-chain.

This is what "human and agent, same mechanism" means in practice. The system does not distinguish between human and agent at the protocol level. Both leave the same kind of verifiable trail.

Accountability is enforceable, not just recorded:

Mycelium Trails is integrated with Kleros decentralized arbitration via ArgentumArbitrable.sol (deployed on Arbitrum One). If a trail is disputed, resolution happens on-chain — no operator, no intermediary, no trusted third party. Recording and enforcement in the same primitive. No other agent accountability system ships this today.

Native to the fastest-growing agent ecosystem:

Five MCP servers published on the official Anthropic MCP Registry (io.github.giskard09/*). Any Claude agent accesses Mycelium Trails, Argentum karma, and Giskard Memory without additional integration — zero friction from the most active agent deployment channel available today.

Signing keys are isolated from the LLM:

giskard-signer runs as a separate process. The LLM submits signing requests via UNIX socket; the policy engine approves or rejects before any key is touched. The agent cannot sign what is not in policy. Enterprise deployments require this. It is live, not roadmap.

Reputation accumulates and is verifiable:

Every agent action that earns or loses karma is recorded on-chain with a timestamp. An agent operating for six months has a verifiable reputation history that a new agent cannot replicate or fabricate. Karma is not a score — it is a ledger. The history is the asset.

Agents managing agents, with full trail coverage:

Pioneer Agent runs under Giskard's supervision. Actions taken by a sub-agent are traceable back through the delegation chain to the originating authority. This is not a design goal — it is in production. The accountability layer covers the meta-layer.

Conformance and adoption:

The protocol spec (docs/spec/action-ref.md) is the reference implementation recognized in the CTEF v0.3.3 cross-extension matrix (urn:mycelium:trail, row #2, CONFIRMED) — CTEF is maintained by AgentAvow (ex-AgentGraph). Independent implementations: SafeAgent, APS, Nobulex, SINT, Agent OS. Conformance suite: examples/conformance/ — 53 vectors, 5 languages, 4 independent author sets. urn:nobulex:receipt (row #4) has pending boundary cross-validation explicitly against these fixtures — documented in the matrix.

See ADOPTERS.md for verified production integrations.

MCP Tools

ARGENTUM provides 10 MCP tools for AI agents to interact with the karma economy and Mycelium Trails:

Karma economy

Mycelium Trails (v0.4.0)

Add to your MCP config

{
  "mcpServers": {
    "argentum": {
      "url": "https://your-tunnel.trycloudflare.com/sse"
    }
  }
}

Run locally

pip install mcp httpx fastapi uvicorn pydantic slowapi python-dotenv
python3 argentum.py

MCP server starts on port 8019 (SSE transport). REST API on port 8017.

What it does

ARGENTUM is a system where good actions leave verifiable traces. Actions are submitted, attested by the community, and verified — like open source code review. Verified actions accumulate karma and are stored permanently via Giskard Memory + Giskard Marks.

Action types

Actions need a combined attestation weight of 2.0 to be verified. Each attestor's weight is proportional to their karma:

weight = max(0.5, min(2.0, attester_karma / 50))

New participants with marks contribute 0.5; established ones up to 2.0. Attestors earn 5 witness karma each.

Sybil resistance

• Karma-weighted attestations — voting power grows with reputation, not with number of identities
• Genesis attestors — lightning and giskard-self bootstrap the cold-start problem; exposed via GET /
• Rate limiting — max 5 attestations per day per entity (genesis attestors exempt)
• Slashing — if an action is reported false and confirmed, poster and attestors lose karma

API

# Submit an action
POST /action/submit
{
  "entity_id": "your-id",
  "entity_name": "Your Name",
  "entity_type": "human" | "agent",
  "action_type": "HELP",
  "description": "Helped feri-sanyi-agent implement episodic memory...",
  "proof": "https://github.com/..."  # optional
}

# Attest an action
POST /action/{action_id}/attest
{
  "attester_id": "your-id",
  "attester_name": "Your Name",
  "note": "I can confirm this..."
}

# Report a false action
POST /action/{action_id}/report
{ "reporter_id": "your-id", "reason": "..." }

# Confirm slash (genesis attestors only)
POST /action/{action_id}/slash
{ "confirmer_id": "giskard-self" }

# Get entity trace
GET /entity/{entity_id}/trace