Hermes Agent Gateway

A permission less infrastructure layer for the Machine Economy. Hermes enables AI agents to autonomously discover, contract, and pay for services on-chain using the MNEE Stablecoin.

Comment

Inspiration

My inspiration was when I noticed that AI agents are becoming incredibly capable at reasoning and coding, but they are still financially paralyzed. Currently, if an autonomous agent wants to access a premium API, buy GPU compute, or store data, it hits a wall. It needs a human to manually sign up, enter a credit card, and hardcode an API key. This bottleneck breaks true autonomy. I wanted to build the missing infrastructure layer that gives agents "wallets" instead of "API keys." I realized that stablecoins like MNEE are the perfect currency for machine-to-machine commerce—permissionless, programmable, and instant. My goal with Hermes was to remove the financial barrier in machine to machine commerce , enabling a frictionless marketplace where code pays code.

What it does

Hermes Agent Gateway is a decentralized middleware that bridges autonomous agents with Web2 services via Web3 payments. Service Discovery: Service providers (like GPU nodes or Oracles) register their endpoints in the Hermes registry. Autonomous Payments: Buyer agents query the registry and pay for services using the MNEE Stablecoin (ERC-20) on the Sepolia network. Verification & Proxy: The Gateway listens for on-chain Transfer events. Once a payment is cryptographically verified (matching the correct amount and recipient), the gateway proxies the request to the service and returns the data to the agent. The result is a system where an AI can wake up, decide it needs more compute, find a provider, pay for it, and use it—all without a single human click.

How we built it

The Backend: A Node.js and Express server acts as the central traffic controller. It handles service registration and request routing. Blockchain Integration: I used Ethers.js to interact directly with the Sepolia testnet. We implemented an event listener that monitors the MNEE Token Contract (0x8cc...) for specific Transfer logs to trigger service provisioning. The Database: I utilized SQLite (via better-sqlite3) to maintain a lightweight, high-speed registry of active nodes and transaction history. The Frontend: I built a React dashboard with a cool aesthetic to visualize the network status, active nodes, and live transaction ledger in real-time. The Agents: For the demo, I wrote custom scripts to simulate "Buyer Agents" that autonomously make purchasing decisions and execute ERC-20 transactions on-chain.

Challenges we ran into

Our biggest challenge was State Management and Reliability. The "Zombie Node" Problem: Early in development, services that crashed or disconnected would remain in the registry, causing "Bad Gateway" (502) errors when agents tried to pay them. This required us to engineer robust "Factory Reset" protocols and cleaner database initialization logic. Event Listening nuances: Getting the backend to reliably filter relevant MNEE transfer events amidst network noise was tricky. We had to ensure the gateway only unlocked services after verifying the specific transaction hash and recipient address to prevent spoofing.

Accomplishments that we're proud of

True Autonomy - successfully demonstrated a script finding a service and paying for it without any hardcoded API keys. The Live Ledger - A the real-time frontend that flashes "SUCCESS" the moment a blockchain transaction confirms felt incredible. It turns abstract backend logic into a tangible visual experience. MNEE Integration - proved that stablecoins are the ideal medium for this exchange, offering the stability agents need to predict costs.

What we learned

Building Hermes taught me that the future of payments isn't about User Experience (UX), it's about Agent Experience (AX). I learned that APIs for agents need to be radically different—they need to be discoverable and pay-per-use, not subscription-based. I also gained deep experience with ethers.js log parsing and the mechanics of ERC-20 event signatures.

What's next for Hermes Agent Gateway

Decentralized Registry - Moving the SQLite database to a smart contract so the registry itself is permissionless and censorship-resistant. Streaming Payments - Integrating protocols like Superfluid so agents can pay for GPU compute by the second, rather than per request. Mainnet Launch - Deploying the gateway for production agents to use real stablecoins for real-world tasks.

Built With

Share this project:

Updates