You Set Up Hermes Agent. Now What? (How to Give Your AI a Wallet That's Safe by Default)

Give a Hermes agent a policy-controlled wallet with OpenClawCash: scoped API keys, env-only secrets, per-transfer policies, and no private keys on disk.

If you've just run the Hermes quickstart, you're probably impressed. It spins up its own subagents, remembers your preferences across sessions, and even writes new skills when you ask. It genuinely feels like an agent, not just a script.

But after the first hour of "whoa, it can search the web and write a markdown file," you hit the real question: "Okay, now what? How do I make this autonomous beyond my laptop?"

Maybe you've already tried giving it a to-do list, or asked it to monitor a dataset. Those things work reasonably well. The trouble starts when you want it to act in the real world, especially where money is involved. An AI that can't pay for its own compute, place a trade, or interact with a smart contract is like a brilliant contractor who isn't allowed to hold the company card. You stay the bottleneck.

So what's the safest way to turn your Hermes instance into an agent that can move value? The short answer is: put a wallet behind it, but don't paste a raw private key into a text file. This article walks through the official integration path, using a service built for this exact problem: OpenClawCash.

Why you need more than a JSON file with a private key

People often start by generating a Solana or Ethereum keypair, dumping it into ~/.hermes/secrets/key.json, and telling the agent to read it. That works for a 10-minute toy demo, but it creates two sharp problems:

Theft risk. If your Hermes instance gets popped, say through a skill you downloaded from a forum, that key is gone along with everything it controlled.
Zero control. The agent can sign anything, anytime, with no spending limits, second factor, or human review. One bad prompt, or one hallucinated transaction, and the account is drained.

A better design keeps key material outside the agent's environment entirely, and gives it scoped, auditable access to a signing service.

OpenClawCash (openclawcash.com) is built for exactly this: encrypted custody on the server, revocable per-agent API keys, and per-wallet spending policies the agent can request actions against but cannot bypass. Your agent never sees the private key. If a key leaks, you revoke it. The wallet keeps its balance.

The fastest integration: install our official skill or MCP server

Skip writing custom Python. We publish two integration artifacts so you don't have to maintain HTTP plumbing yourself.

Option A: drop in the official skill

Hermes (and any agent that loads markdown skills from a local directory) can use the same skill we maintain for Claude. Clone it into your skills folder:

cd ~/.hermes/skills
git clone https://github.com/openclawcash/agentwalletapi.git

The skill ships with usage docs and helper scripts for wallets, balances, transfers, swaps, and cross-chain bridging. Set one env var and restart the agent:

## ~/.hermes/config.yaml
env:
  AGENTWALLETAPI_KEY: "occ_your_real_key"

That's it. The agent now has a wallet capability that picks up updates whenever we publish a new skill version, with no edits to your local files.

Option B: MCP server (one line, any MCP-compatible client)

If your agent speaks the Model Context Protocol (Claude Code, Cline, Cursor, and a growing list), skip the skill folder entirely. Point your client's MCP config at our server:

{
  "mcpServers": {
    "openclawcash": {
      "command": "npx",
      "args": ["-y", "@openclawcash/mcp-server"],
      "env": { "AGENTWALLETAPI_KEY": "occ_your_real_key" }
    }
  }
}

The MCP server exposes the same wallet, balance, transfer, swap, and bridge tools as the skill, but as first-class MCP tool calls so your agent can introspect and call them without any prompt engineering.

Pick whichever your runtime supports. The rest of this article works with either.

Step-by-step: from zero to a working agent wallet

Step 1: Generate an API key with the smallest blast radius

Go to openclawcash.com, create an account, and generate an API key. For your first integration, the toggles you actually have on the create-key form are:

Allow this key to create wallets via API: turn on. The agent needs this to provision its own wallet.
Allow this key to import wallets via API: leave off. You're not handing the agent existing keys.
Allow live transactions: turn off. With this off, the key can only act on testnets, so any mistake is costless.
Chain scope: pick solana or evm to limit reach to one chain, or leave on all.
Wallet scope: pick single wallet once you've created one, so the key cannot touch other wallets on your account.
Venue scope, checkout scope: leave at their defaults; you don't need them for a basic wallet integration.

Reads (wallet metadata, balances) are not gated by a separate toggle, so the agent will be able to read state regardless. Transfers are gated by the live-transactions flag, the chain scope, the wallet scope, and the per-wallet spending policies you set on the dashboard.

Once the agent's behavior is predictable, generate a separate key with Allow live transactions on and matching spending policies for production use.

Set the key you just generated as AGENTWALLETAPI_KEY in the env file (skill) or MCP config (MCP) above.

Step 2: Create a wallet through the agent

Restart Hermes (or your MCP client) and ask:

"Create a new Solana wallet, then show me the wallet id and address."

The agent calls the skill or MCP tool, hits /api/agent/wallets/create on your behalf, and prints back the result. The private key for that wallet was generated server-side, encrypted at rest, and never returned to the agent.

Step 3: Fund the wallet

Copy the address, send a tiny amount of SOL (0.001 is plenty), and ask:

"Check the balance of wallet <wallet_id> on Solana."

You should see the balance returned. Your agent just interacted with real value, without ever touching a private key.

Step 4: Adding signable transactions (with your approval)

Once you're comfortable with the testnet flow, generate a separate API key with Allow live transactions on. Then attach spending policies to the wallet itself on the dashboard, picking the ones that fit your use case: per-transfer cap, daily cap, weekly cap, address whitelist, max open escrows, trusted counterparty tags. The policies live on the server, attached to the wallet, not to the key. The agent can request a transfer, but the server refuses to sign anything that violates a policy.

The skill and MCP both expose transfer. Ask:

"Transfer 0.001 SOL from wallet <wallet_id> to <address>."

If the request is within policy, you get a tx hash back. If not, you get a clear policy-violation error.

What this unlocks

Once your Hermes agent has a funded wallet under controlled spending, a few real workflows become practical:

Self-maintaining agent. The agent monitors its own VPS cost and pays its cloud provider or API credits using USDC on Solana or Ethereum. You set a monthly budget on the wallet policy and walk away.
On-chain monitoring and execution. Hermes reads a DEX price feed, and when a threshold is hit, requests a swap. The transfer is signed only if the request matches the policy you configured.
Web3 interaction without raw-key risk. Claiming an airdrop, voting, or interacting with a protocol becomes safer because the agent's request is authenticated via a scoped API key, and the wallet's keys were never on disk.

None of this requires Hermes to hold raw key material. That's the whole point.

Alternatives you might consider (and why I still use OpenClawCash)

The "burner key" approach. Generate a new keypair, put it in a file, and only send it pocket change. Fine for experiments, but not for an agent you want to trust with ongoing tasks.
A hardware wallet plus a script. You could connect a Ledger to a script and have Hermes call it. That solves the key security but introduces physical babysitting and makes remote autonomy impossible.
Other custodial APIs. A few exist, but most are designed for institutions or human users, not for programmatic agent access. OpenClawCash's API is purpose-built for AI agents: simple X-Agent-Key auth, per-agent keys, policy-aware execution, and the same surface across EVM and Solana.

If you just want to play, start with the burner key. If you're serious about giving an agent financial legs, use a backend designed for the failure modes agents actually have.

Frequently Asked Questions

How do I give my Hermes agent a wallet without exposing the private key? Use a service that custodies the key for you and only exposes a scoped, revocable API key to the agent. OpenClawCash generates the wallet's private key server-side, encrypts it at rest, and never returns it to the agent. The agent can request transfers, but signing happens on the server under the policies you configured for that wallet.

What is the fastest way to integrate OpenClawCash with Hermes? Clone the official skill from https://github.com/openclawcash/agentwalletapi.git into ~/.hermes/skills, then set AGENTWALLETAPI_KEY in ~/.hermes/config.yaml and restart the agent. No custom HTTP code is required, and the skill picks up new wallet, swap, transfer, and bridge endpoints automatically as they ship.

Does OpenClawCash work with AI agents other than Hermes? Yes. The same skill works with any agent runtime that loads markdown skills from a local directory. For Model Context Protocol clients (Claude Code, Cline, Cursor and others), the @openclawcash/mcp-server npm package exposes the same wallet, balance, transfer, swap, and bridge tools as native MCP tool calls.

Can I limit how much my AI agent can spend? Yes. Spending is gated server-side by policies attached to each wallet: per-transfer cap, daily cap, weekly cap, monthly cap, address whitelist, max open escrows, trusted counterparty tags, and a testnet-only flag. The agent can request a transfer, but the server refuses to sign anything that violates a policy.

What happens if the agent's API key leaks? Revoke the leaked key from the OpenClawCash dashboard. The wallet keeps its balance because the wallet's private key was never bound to the API key. Issue a fresh key with the same scopes and policies and the agent is back online without any on-chain migration.

Do I need to write Python or any custom HTTP code? No. Both the official skill and the MCP server abstract the HTTP plumbing. You only need to set AGENTWALLETAPI_KEY for the agent runtime to use, and ask the agent in natural language to create wallets, check balances, transfer, swap, or bridge.

The bottom line

Hermes is great at reasoning and memory. The next leap is execution: letting it move money as carefully as it moves ideas. That leap requires infrastructure that treats every transaction as potentially suspect, and that never hands a raw private key to a code model that sometimes hallucinates.

That's what we're building at OpenClawCash: the wallet layer for autonomous agents. Not a flashy dApp, but the boring-but-critical plumbing that keeps your agent's financial life safe.

Go to openclawcash.com, install the skill or the MCP server, run through the steps above, and see for yourself. When you're ready to let your agent spend, upgrade to a transfer-capable key with the policies that make sense for you.

Stop treating your local AI like a toy. And stop treating its wallet like an afterthought.