Building a Multi-Chain Agent Economy at ETH Denver with Festival

I started this on February 16, 2026, two days before ETH Denver’s on-site build opened at BUIDL Hub. I was a solo builder with a workspace, a stack of sponsor bounty pages, and a constraint I was not willing to drop. If an agent is going to trade, a human has to be able to stop it, and the agent has to be unable to spend past the limits that human set.

The result is the Obey Agent Economy: a coordinator on Hedera, a DeFi agent on Base, an inference agent on 0G, a Chainlink CRE risk router on Ethereum, Solidity vaults and settlement contracts, a Hiero CLI plugin, and a read-only dashboard. Eight repositories. Six chains. Ninety-plus verified transactions.

I did not prompt my way through that. I ran it as a Festival campaign. This post is the build, the repos, and the method.

What I was actually building

ETH Denver 2026 had the usual spread of sponsor tracks. Hedera, 0G, Base, plus a pile of smaller ones. The tempting move is one toy per bounty. I built one system that could honestly show up on several tracks because the pieces needed each other.

A coordinator reads a structured plan, publishes tasks onto Hedera Consensus Service, and pays agents in HTS when the work clears a quality gate. A DeFi agent on Base trades USDC/WETH through an ERC-4626 vault that enforces the spending envelope in the contract. An inference agent on 0G discovers GPU providers on-chain, runs the job, stores the result, and mints an ERC-7857 iNFT so the provenance is not a log file. Before any swap hits the vault, a Chainlink CRE workflow runs eight sequential risk gates and writes the decision on-chain via DON consensus. A dashboard watches. I am not operating the agents. I am watching them, and I sit on the gates.

The product claim is the same at every layer. The agent can propose a trade, and the vault can refuse it. There is no prompt that talks the contract out of that.

Festival is how one person ran eight repos

I build Festival. I also run everything through it. Obey is the first time I pointed it at a multi-chain hackathon as a single campaign instead of a pile of chats.

Festival is a free, open command-line tool. It does not replace Claude Code, Codex, Grok, or whatever agent you already use. It gives the agent the structure a long piece of work is missing: a workspace, a plan, and a way to verify what came back.

Three layers, all files on disk:

• Context. camp creates a campaign: one git-tracked directory that holds every repo, design doc, and research note. An agent starting a session reads the campaign instead of a blank chat.
• Direction. fest turns an outcome into a festival: phases, then sequences, then tasks, each with acceptance criteria. fest next returns the next step as instructions. The standing loop is: run fest next, do that step, commit, go again.
• Verification. Review and commit are tasks in the same tree. Quality gates evaluate against artifacts, not the agent’s memory of having done the work. fest commit ties the git history back to the task.

That is the whole design. It looks almost too small to matter until you look at the calendar. Campaign created February 16. Coordinator HCS, HTS, and schedule packages landing February 20. The Hiero plugin, the dashboard, and the first DeFi sequences closed the same day. Four days from an empty workspace to real packages across multiple repositories, because the plan was already decomposed and the agents could execute without me restating the goal every turn.

I sat on the gates. The agents picked up fest next.

Festival is also in the runtime, not only the planning. The coordinator reads festival-structured plans and publishes progress onto HCS. The standalone vault agent runs research as a ritual festival: ingest market data, decide GO or NO_GO, and only then call the vault. If the ritual says NO_GO, there is no swap. The dashboard’s Festival View panel renders that tree live.

Install it, then star the repo so other people building with agents can find it:

# npm
npm install -g @obedience-corp/festival

# macOS
brew install --cask Obedience-Corp/tap/festival

fest.build · docs · github.com/Obedience-Corp/festival

The eight repositories

Each piece lives in its own git repo and comes into the campaign as a submodule. That is a camp workspace, not a monorepo I pretended was simple.

agent-coordinator

The coordinator is the hub, and it is Hedera-native. No Solidity on that path. It reads the festival task graph, publishes assignments onto HCS topic 0.0.7999404, listens for results and heartbeats on 0.0.7999405, and settles in AGNT via HTS when a quality gate passes.

Every message is an Envelope: type, sender, recipient, task ID, sequence number, JSON payload. Task types include task_assignment, task_result, heartbeat, quality_gate, payment_settled, and pnl_report. Tasks move through a state machine: pending, assigned, in progress, review, complete, paid. A failed gate sends the work back to in progress. Failed tasks retry.

HIP-1215 Schedule Service covers deferred settlement and liveness proofs. Each agent gets its own Hedera testnet account and ED25519 key. The coordinator talks to the obey daemon over gRPC when a step needs a sandboxed session.

agent-defi

Two binaries share this repo.

agent-defi is coordinator-driven. It receives HCS tasks, runs a mean-reversion loop on Uniswap V3 USDC/WETH on Base Sepolia, and reports P&L back over HCS. Buy and sell fire on a 2% deviation from a 30-period moving average. Position size follows confidence.

vault-agent is the standalone OBEY Vault Agent. Each cycle runs a research ritual, evaluates CRE gates, and only then calls executeSwap on the vault. loggen rebuilds agent_log.json from on-chain SwapExecuted events and ritual artifacts, which is what Synthesis wanted as receipts.

On-chain identity is ERC-8004 on Base, testnet and mainnet. When a resource returns HTTP 402, the agent pays USDC through x402 and retries with proof. ERC-8021 builder codes go on the calldata so the transactions attribute back to the builder.

cre-risk-router

This is the piece that placed 2nd in Autonomous Agents at Convergence: A Chainlink Hackathon 2026.

An agent proposes a signal. A CRE workflow on a cron trigger runs eight gates in order. The first denial short-circuits. Approved signals get a constrained position. Every decision, approved or denied, is ABI-encoded, signed by DON consensus, and written to RiskDecisionReceipt on Ethereum Sepolia. The contract implements CRE’s IReceiver (onReport(bytes,bytes)). Duplicate prevention and TTL expiry live there, not in the agent.

The workflow is Go compiled to WASM (wasip1), [email protected], evm-write for the receipt. No extra orchestrator sitting next to it.

agent-inference

The inference agent is the 0G side of the economy. It takes HCS assignments, discovers GPU providers from the on-chain InferenceServing contract, and dispatches jobs over an OpenAI-compatible API. No centralized API key. No single-provider lock-in.

Results go to 0G Storage (Flow contract submit before the blob upload). An ERC-7857 iNFT holds AES-encrypted metadata: model config, memory, knowledge base, strategy weights. Only the owner can decrypt. A TEE oracle handles transfer on sale. 0G DA gets the audit event: agent ID, task ID, job ID, storage ref, iNFT ref.

The task_result back on HCS carries the storage content ID, iNFT token ID, and DA submission ID. If you want to argue the agent did the work, that is the trail.

contracts

Foundry, Solidity 0.8, tests included.

• ObeyVault. ERC-4626. Token whitelist, max swap size, daily volume cap, slippage limits, guardian pause. Uniswap V3 exactInputSingle with TWAP oracle NAV. This is the envelope.
• AgentSettlement. Pays agents for completed tasks, single or batch, with bytes32 task IDs so you cannot pay twice. HIP-1215 schedules the batch for later.
• ReputationDecay. Activity timestamps and linear decay for agents that go quiet.
• AgentINFT. ERC-7857 provenance on 0G Chain.
• AgentIdentityRegistry. ERC-8004 identity on Base, also deployed gasless on Status Network.

dashboard

Next.js, read-only. Six panels: Festival View, HCS Feed, CRE Decisions, Agent Activity, DeFi P&L, Inference Metrics. Mock data for just demo. WebSocket from the obey daemon for live heartbeats. Hedera Mirror Node for historical HCS. If a judge cannot see the agents, the rest does not matter. That is why this repo exists.

hiero-plugin

A TypeScript plugin on the Hiero CLI. hcli camp init, hcli camp status, hcli camp navigate. It wraps the camp binary, which is the point: Festival workspace management inside the Hedera developer CLI.

Five templates: hedera-smart-contract, hedera-dapp, hedera-agent, 0g-agent, 0g-inft-build. Built for Hedera Track 4 at ETH Denver 2026, with 0G templates in the same plugin because the campaign already spanned both.

The vault is still the product

ObeyVault on Base Sepolia is where the constraint becomes real. I set the envelope. The agent calls executeSwap. If the call violates a bound, it reverts.

Before the vault sees the swap, CRE has already run. After the vault executes, the receipt is on Sepolia and the swap is on Basescan. Identity is on Base mainnet. Status Network got a gasless registry deploy, gas price zero.

The agents are Go. The contracts are Solidity with Foundry tests. The observer UI is Next.js. From the campaign root:

git clone --recursive https://github.com/lancekrogers/Obey-Agent-Economy.git
cd Obey-Agent-Economy
just install
just demo

just live fails fast if the testnet preflight is not actually ready.

ETH Denver, Convergence, and Synthesis

ETH Denver 2026 is why the campaign exists. Online build started February 12. On-site opened February 18. I initialized the workspace on the 16th and pointed it at Hedera, 0G, and Base as one economy instead of three disconnected demos. The Hiero plugin is the tooling track. The coordinator, vault, inference agent, and dashboard are the rest of that bet.

Chainlink Convergence ran February 23 through March 8, 554 submissions. The CRE Risk Router was a fit because it is a CRE workflow: cron, eight gates in Go WASM, evm-write for the receipt. I submitted it on the Autonomous Agents track. Chainlink announced winners on April 6. CRE Risk Router took 2nd place.

Synthesis closed March 22. I published on March 19 and submitted to six tracks: Let the Agent Cook, Agents With Receipts, Agentic Finance, Open Track, Autonomous Trading Agent, and Go Gasless. For that one I wanted a loop I could describe without hedging: research ritual, CRE gates, vault execution, structured log, on-chain receipt. No fake log entries.

Same campaign, same Festival tree, three programs.

If you want the method, or the code

The Obey Agent Economy is what Festival looks like when the work is eight repositories, six chains, and a vault that has to be allowed to say no.

Festival is free and open. It works with Claude Code, Codex, Grok, Cursor, and anything else that can run a shell command and read a file.

npm install -g @obedience-corp/festival
camp create my-project && cd my-project
fest create festival --name "my-first-feature" --type standard

fest.build · star Obedience-Corp/festival

Obey is public.

github.com/lancekrogers/Obey-Agent-Economy · CRE Risk Router