Forem: OpenClaw Cash

Hermes Agent Ready? Here’s How to Safely Give It a Wallet

OpenClaw Cash — Tue, 05 May 2026 20:31:29 +0000

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.

(Not chasing DeFi just yet? That’s fine Hermes is also great for automating personal tasks, summarizing research, or managing your homelab. We’ll cover those paths in another post. This article is for the moment you decide your agent needs financial legs.)

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. Here’s exactly how to do it with OpenClawCash, a service built to give AI agents secure MPC wallets without the agent ever holding the keys.

Before you start: what you’ll need

Hermes installed and working (you’ve already run the quickstart)
Node.js 18+ on the same machine (the MCP server runs locally via npx)
A tiny bit of crypto for testing 0.001 ETH on Sepolia testnet, or 0.001 SOL on devnet (we’ll stay on testnets until you’re comfortable)
An OpenClawCash account (free tier is fine; you’ll generate an API key in a moment)

The security model in one paragraph

OpenClawCash gives you MPC wallets the private key is split into shares that are never assembled in one place. Your Hermes agent communicates with the service through an API key, which you can scope with policies: spending limits, address allowlists, and even transaction‑type restrictions. The agent never sees a raw key. Even if someone compromises your Hermes instance, they can’t drain the wallet beyond the limits you’ve set ahead of time. We’ll start you with a read‑only key so you can test everything with zero risk.

Path A (Cleanest): Add the MCP server to Hermes

Hermes has first‑class MCP support. You can register external tools by adding an MCP server to its config, and Hermes will automatically discover all the wallet actions: balance checks, transfers, swaps, and more.

OpenClawCash publishes @openclawcash/mcp-server on npm. It runs locally over stdio—no network ports opened and forwards requests to the OpenClawCash API using your agent key.

Step 1: Get your API key

Sign up at openclawcash.com, create a workspace, and generate an API key. For now, choose the “Read‑only” permission set. You’ll be able to list wallets and check balances, but no money can move. Later, when you’ve seen it work, you can create a new key with a daily spend limit.

Step 2: Add the server to Hermes

Open your Hermes config file (~/.hermes/config.yaml) and add this block under mcp_servers:

mcp_servers:
  - name: openclawcash
    command: npx
    args: ["-y", "@openclawcash/mcp-server"]
    env:
      AGENTWALLETAPI_KEY: occ_your_readonly_key_here
      AGENTWALLETAPI_URL: https://openclawcash.com

What this does: every time Hermes starts, it will spawn a local Node process, load the MCP server, and connect it via stdin/stdout. The -y flag tells npx to install the package automatically if it’s missing. Because it’s a stdio server, it stops when Hermes stops nothing lingers in the background.

Step 3: Verify everything works

Restart Hermes, then in the Hermes terminal run the server’s built‑in self‑test:

npx -y @openclawcash/mcp-server --self-test

If you see a green success message, Hermes now has wallet tools. You can also ask the agent directly:

“List my accessible wallets and their balances.”

Hermes should respond with a list likely empty at first, because you haven’t created any wallets yet. That’s fine.

Path B (Simplest): Drop in the skill file

If you’d rather not touch YAML or Node, OpenClawCash also provides a standalone SKILL.md that works with any agent framework. Hermes reads skills from ~/.hermes/skills/, so you can simply place the file there.

Here’s the one‑line install:

curl -o ~/.hermes/skills/openclaw_wallet.md https://openclawcash.com/skills/latest

Then set your API key as an environment variable before launching Hermes:

export AGENTWALLETAPI_KEY=occ_your_readonly_key_here

Hermes will pick up the skill on next start. You can then ask it to generate a new address or check balances, just like in Path A.

(The skill file is auto‑generated from the latest API docs; you can always re‑download it with the same command to stay up to date.)

Your first transaction: a baby‑step walkthrough

Let’s move past theory. Assume you’ve completed Path A and Hermes is running with the MCP server. You now have a read‑only key. We’re going to:

Create a testnet wallet
Fund it with 0.001 testnet ETH
Upgrade to a spending key (with a tiny limit)
Make a real transfer and watch the policy guard it

1. Create a wallet

In the Hermes terminal:

User: Create a new Ethereum wallet on the Sepolia testnet.
Hermes: [calls create_wallet tool] Done. Your new Sepolia address is 0xABCD…1234.

2. Fund it

Go to a Sepolia faucet (google “Sepolia faucet”), paste the address, and send 0.001 ETH. Wait a moment, then:

User: Check the balance of 0xABCD…1234.
Hermes: Balance: 0.001 ETH.

3. Upgrade to a spending key

Back on openclawcash.com, create a new API key with these settings:

Permission: Sign transactions
Daily limit: 0.0005 ETH (less than what’s in the wallet)
Allowed recipient addresses: (leave open for now, or whitelist a friend’s address)

Update your Hermes config to use this new key, and restart the agent.

4. Attempt a transfer

Now try sending 0.0003 ETH to another Sepolia address you control:

User: Send 0.0003 ETH from 0xABCD…1234 to 0xRECIPIENT…5678.
Hermes: [calls transfer tool] Transaction submitted. Policy check passed. TX hash: 0x….

If you later try to send more than the 0.0005 daily limit, the MPC policy will reject it before it ever hits the chain. That’s your safety net in action.

What you can actually do with this (non‑hypothetical examples)

Once you’re comfortable on testnet, switch to mainnet with a spending limit that matches your risk tolerance. Then:

Self‑maintaining agent: The agent monitors its own VPS cost and pays its cloud provider or API credits using USDC. You set a monthly budget and forget it.
On‑chain monitoring and execution: Hermes reads a DEX price feed, and when a threshold is crossed, requests a swap. The MPC wallet signs only if the transaction respects your limits.
Web3 interaction without fear: Claiming airdrops or interacting with protocols becomes safer because the agent’s request is authenticated, and the wallet’s keys were never on disk.

But what if I don’t want to touch crypto today?

No pressure. Hermes is still an incredible automation engine without a wallet. A few high‑value, non‑financial things you can try right now:

Personal knowledge base: Point Hermes at your local markdown notes and let it answer questions across all of them.
Home lab assistant: Integrate it with Home Assistant or run scheduled checks on your servers.
Research synthesis: Feed it a bunch of PDFs and ask it to produce a structured summary.

We’re focusing on wallets here because financial execution unlocks a new tier of autonomy but it’s entirely optional. When you’re ready to explore that tier, OpenClawCash makes it safe.

Give it a shot start with testnet, zero risk

Hermes solves the reasoning and memory problem beautifully. Adding financial execution lets it actually act on those insights, but it has to be done with guardrails. OpenClawCash provides those guardrails: MPC wallets, policy enforcement, and an integration that takes minutes to wire up.

Here’s my honest suggestion:

Sign up at openclawcash.com, grab a read‑only key.
Add the MCP server to your Hermes config (or drop in the skill file).
Create a Sepolia wallet, fund it with free testnet ETH, and check the balance.
Only then, when you’ve seen it work, create a spending key with a tiny limit and try a real testnet transfer.

You’ll have a financialised AI in under an hour and you’ll sleep easy knowing it can’t drain your savings on a bad prompt.

Ready to try it? Head to Sign up get your key and spin up your first agent wallet. No raw keys, no fear just your AI, finally able to make moves.

How to Give Your AI Agent a Wallet in 5 Minutes with OpenclawCash.com

OpenClaw Cash — Tue, 14 Apr 2026 16:56:19 +0000

AI agents are becoming useful, but most of them still cannot safely move money onchain. OpenclawCash gives your agent a wallet, policy controls, and API endpoints for transfers and swaps across EVM and Solana chains.

In this post, you'll see the basic flow: authenticate with an agent key, inspect a wallet, and make a first onchain action with OpenclawCash.

Why this matters

Most agent demos stop at "the model can suggest an action." That is not enough when the action is moving assets. OpenclawCash is built for the part that matters in production: letting an AI agent hold a wallet and act under policy controls instead of raw key access.

That makes it useful for agents that need to:

Send payments.
Swap tokens.
Run autonomous workflows with guardrails.
Work across EVM chains and Solana in a single setup.

What you'll build

By the end of this tutorial, your agent will be able to:

Authenticate with an OpenclawCash agent key.
List wallets.
Read wallet details and balances.
Send a transfer.
Run a token swap.

Prerequisites

You need:

OpenClawCash Agents
An agent key
Python or Node.js to make API requests.

Bonus

Use Code PAYME26 on signup to get 10 days free use.

Step 1: Authenticate your agent

Prompt:
Connect to my OpenclawCash wallet.

Example output:
✓ Connected to OpenclawCash agent wallet
Ready for wallet actions.

OpenclawCash uses an agent key passed in the X-Agent-Key header. That header is the most important piece of the setup because it lets your agent call the wallet API without exposing private keys in your application logic.

Step 2: List available wallets

Prompt:
Show me my available wallets.

Example output:
You have 2 wallets available:
- Main: 0.42 ETH, 128 USDC (Ethereum)
- Test: 0.01 SOL (Solana)

If your agent has access to more than one wallet, this is where you can choose the right one for the task. One wallet might be used for testing, while another is reserved for live transfers.

Step 3: Read wallet balance

Prompt:
What's my wallet balance?

Example output:
Main wallet balance:
- 0.42 ETH ($1,250)
- 128.45 USDC ($128)
- 0.01 SOL ($1.50)

This is the point where your agent can make a simple decision:

If balance is too low, stop.
If balance is sufficient, continue.
If the asset is wrong, swap first.

That sort of logic is exactly why a wallet layer for agents matters.

Step 4: Send a transfer

Prompt:
Send 0.01 ETH to 0x1234567890abcdef.

Example output:
✓ Transfer sent successfully
Tx: 0xabc123... | 0.01 ETH | Confirmed on Ethereum
Gas used: 21,000 | Status: Success

This example shows the basic idea: the agent chooses a wallet, a destination, a token, and an amount. OpenclawCash handles the wallet infrastructure so the agent can execute the transfer in a controlled way.

For a real production setup, you should add policy checks before the transfer runs. For example:

Maximum amount per transfer.
Allowed destination list.
Network restrictions.
Manual approval for large amounts.

Step 5: Swap tokens

Prompt:
Swap 0.05 ETH to USDC.

Example output:
✓ Swap completed
0.05 ETH → 145.20 USDC
Tx: 0xdef456... | Status: Confirmed

Agents often need to change assets before acting. OpenclawCash supports swaps as part of the same wallet workflow. That means your agent can do more than just move funds. It can prepare the right asset for the next step in an automated workflow.

A simple agent flow

Here is the simplest real-world flow for an AI agent:

Prompt:
Send 25 USDC to @user123 wallet.

Example output:
Checking balance... ✓ 128 USDC available
Sending payment... ✓ 25 USDC transferred
Tx: 0x789... | Status: Confirmed

That pattern is enough for many practical uses:

Paying a service onchain.
Funding a worker wallet.
Rebalancing small treasury flows.
Executing a limited DeFi action under policy.

Example use case

Imagine a support agent that receives a request to reimburse a user in USDC.

Prompt:
Reimburse @user456 25 USDC.

Example output:
✓ Balance check passed (128 USDC available)
✓ Payment sent: 25 USDC to @user456 wallet
Tx: 0x789... | Status: Confirmed ✓

The agent can then check the wallet balance, swap a small amount of ETH to USDC if needed, transfer the final amount to the recipient, and record the transaction for review.

That is much more useful than a chatbot that can only suggest what should happen.

Production advice

If you plan to use OpenclawCash in a live product, keep the agent restricted. A good rule is to let the model decide what should happen, while your policy layer decides whether it is allowed.

A solid first policy set would include:

Spending limits.
Whitelisted addresses.
Per-network restrictions.
Manual review for large transactions.

That keeps the system practical without giving the model unrestricted financial control.

Closing thoughts

OpenclawCash makes it straightforward to give an AI agent a wallet, connect it to real onchain actions, and add policy around those actions. If you want your agent to do more than talk about money, this is the missing layer.

Resources

AI #AIagents #Web3 #Crypto #Blockchain #Solana #Ethereum #DeFi #developers #tutorial #buildinpublic #100DaysOfCode #showdev #programming

In the last 7 days we generated +7,735.24 USDC PnL on Polymarket using OpenClawCash.

OpenClaw Cash — Wed, 08 Apr 2026 21:57:38 +0000

We posted a 60% win rate, +24.18% avg PnL, and +31.89% EV proxy all while keeping private keys fully protected.

Every other setup we tried was bottlenecked by slow wallet flows, tab-switching, and manual approvals. Ours wasn’t.

Prediction market trading has always been bottlenecked by execution friction. You spot the edge, then lose it copying prices, approving transactions, and juggling dashboards. We wanted a cleaner loop: scan → decide → place → monitor, without exposing keys to agents or scripts.

So we built the workflow around OpenClawCash.

Here’s what it actually does

Point OpenClawCash at your Polymarket account via secure API. It gives you one unified dashboard with live PnL, exposure, collateral, and redeemable positions. No seed phrases. No wallet connections. Just fast, secure order placement.

The setup is minimal by design:

Sign up at https://openclawcash.com
Run the Polymarket Setup Wizard (2 minutes)
Generate API key + grant venue access
You’re live

Then the loop:

Scan markets for EV-positive setups
Place limit orders in seconds
Monitor real-time risk in one place
Realize PnL or redeem positions
Repeat

Why this works

We discovered that the biggest edge in prediction markets isn’t just better models or more alpha—it’s understanding how fast the market moves and how slow manual flows actually are. OpenClawCash lets the trader operate at the speed of their own edge instead of the speed of their wallet.

Practical consequence: The same trader + OpenClawCash consistently beats the same trader on raw Polymarket UI. The tool doesn’t add alpha; it removes every tiny friction that kills edge.

Emergent behaviors we didn’t program

Repeated small-to-medium EV-positive trades instead of chasing moonshots
Clean exposure management across 5+ active markets at once
Natural focus on Sports (where the majority of our volume landed this week)
Steady cumulative PnL curve with zero operational panic

Results: In 7 days OpenClawCash delivered

PnL (7D): +7,735.24 USDC
Win Rate (7D): 60% (18 wins / 12 losses)
Avg PnL % (7D): +24.18%
EV Proxy (7D): +31.89%

All numbers pulled live from the dashboard.

What we learned

Speed compounds. The faster the loop, the more EV-positive setups you can actually take.
Visibility is everything. When you see total exposure and redeemables in one place, you make better sizing decisions.
Operational simplicity wins. Removing wallet friction let us focus purely on the edge instead of the plumbing.

Why this matters

The hard part of trading prediction markets isn’t finding edge — it’s executing it consistently at scale. Most traders have hundreds of micro-decisions every week. No one can hand-manage that friction across dozens of markets.

OpenClawCash collapses that. You define your edge. The tool handles the rest. This is infrastructure for serious prediction market traders: continuously scanning, executing, and scaling without the usual headaches.

What’s next

We’ll be dropping transparent weekly updates every Sunday—exact PnL, win rates, and markets played.

Want the full strategy prompt we used?
Retweet this post + comment “STRATEGY” and we’ll DM it to you.

Quick Start Guide (live in <10 minutes)

Sign up at https://openclawcash.com
Complete the Polymarket Setup Wizard
Generate your API key and grant venue access
You’re ready to trade

See you in the markets. 🚀

Read the full story here: https://openclawcash.com/blog/polymarket-7-day-results-openclawcash

Your AI Agent Can Think. But Can It Pay?

OpenClaw Cash — Mon, 30 Mar 2026 17:32:37 +0000

The unsolved plumbing problem behind autonomous agents and how to fix it in 10 minutes.

You've built an AI agent that can reason, plan, and act. It can browse the web, write code, send emails, and make decisions that would have taken a human hours.

Then it needs to pay for something.

And everything breaks.

The Gap Nobody Talks About

The AI agent ecosystem has exploded. Frameworks like OpenClaw, LangChain, and ElizaOS let you spin up autonomous agents in an afternoon. You can give them memory, tools, personalities, and goals.

But there's a structural gap that almost every agent builder hits eventually: agents can't hold money safely.

This isn't a minor inconvenience. It's a foundational problem. And the ways people currently work around it range from "bad idea" to "catastrophically bad idea".

Let me show you what I mean.

What People Actually Do Today

When an agent needs to transact on-chain, here's what most builders end up doing:

Option A: Hardcode a private key in the agent's environment

PRIVATE_KEY=0xdeadbeef...

The agent has full, unrestricted, permanent access to the wallet. No spending limits. No audit trail. No way to revoke access without rotating the key everywhere. If the agent hallucinates a bad transaction or gets prompt-injected it can drain the wallet completely.

Option B: Give the agent a "throwaway" wallet with a small balance, top it up manually

This works until it doesn't. You're now a human top-up machine. The moment your agent needs to do something while you're asleep, it fails. This isn't autonomous it's remote-controlled.

Option C: Build your own wallet management layer

Some serious teams go this route. They build a backend service that holds keys, exposes a restricted API to the agent, logs transactions, and handles gas estimation. It takes weeks, it needs security review, and it's not the product they're trying to build.

None of these are good. All of them are load-bearing.

Why This Is Harder Than It Looks

The root problem is that crypto wallets weren't designed for delegation.

A private key is binary: you either have it or you don't. If an agent has the key, it has unlimited power over that wallet. There's no native concept of:

"this agent can spend up to 0.1 ETH per day"
"this agent can only send to pre-approved addresses"
"this agent can swap but not transfer out"

Compare this to how humans handle financial delegation: we have corporate cards with category limits, expense approvals, audit trails, and revocable access. None of that exists natively in a raw private key.

So when you give an agent a private key, you're essentially handing a new employee your personal bank account password and saying "be careful."

The Three Properties You Actually Need

Before looking at solutions, it helps to get clear on what "agent-safe" wallet access actually means. You need three things working together:

1. Scoped permissions, not root access

The agent should only be able to do what it needs to do. A trading agent needs swap access. A payment agent needs transfer access. Neither should be able to create new wallets or import external keys. Permissions should be granular, set in advance, and enforced server-side not trusted to the agent's judgment.

2. Policy controls that survive prompt injection

Spending limits and address restrictions need to live outside the agent's context window. If your safety guardrails are just in the system prompt, a sufficiently clever user message can override them. Actual enforcement needs to happen at the API layer, not the LLM layer.

3. Auditable history that's useful at 3am

When something goes wrong and something will go wrong you need a log that tells you exactly what the agent did, when, and why. Not just successful transactions, but failed attempts, rejected transfers, and policy violations.

A Practical Solution: The Managed Wallet API Pattern

The cleanest architecture I've found for this is what you might call a managed wallet API: a service that holds keys server-side, exposes a restricted HTTP API to agents, and enforces policy controls at the infrastructure level.

Here's how it works in practice with OpenclawCash:

Step 1: Create a wallet and set policy

In the dashboard, you create a managed wallet for your agent. You set the policies upfront:

Max transfer amount per transaction
Allowed destination addresses (whitelist)
Whether the API key can create new wallets or only operate existing ones

The wallet's private key never leaves the server. Your agent never sees it.

Step 2: Issue a scoped API key

You create an API key with specific permissions. This key is what your agent uses, not a private key. If you need to revoke access, you delete the API key. The wallet stays intact.

X-Agent-Key: ag_your_key_here

Step 3: The agent calls the API

Now your agent can check balances, transfer tokens, or run DEX swaps via simple HTTP calls. On EVM chains it uses Uniswap routing. On Solana it uses Jupiter. The agent doesn't need to know anything about gas estimation, nonce management, or RPC endpoints.

Check balance:

GET /api/agent/wallet?walletId=w_123

{
  "address": "0xabc...",
  "nativeBalance": "0.45 ETH",
  "tokens": [
    { "symbol": "USDC", "balance": "250.00" }
  ]
}

Execute a swap:

POST /api/agent/swap
{
  "walletId": "w_123",
  "chain": "ethereum",
  "fromToken": "ETH",
  "toToken": "USDC",
  "amount": "0.1"
}

If the amount exceeds the policy limit, the API returns a 403 the transaction never touches the chain. The agent gets a clear error it can reason about.

Step 4: Everything is logged

Every API call, successful or rejected appears in the activity history. You can see exactly what your agent tried to do, what was allowed, and what was blocked.

Integrating with OpenClaw in 10 Minutes

If you're running an OpenClaw agent, there's a pre-built skill for this. Here's the full setup:

1. Install the skill

In your OpenClaw skills directory:

# The skill is available in the OpenClaw skills registry
# Search for: agent-crypto-wallet

2. Configure your API key

# In the skill's .env file:
AGENTWALLETAPI_KEY=ag_your_key_here

Get your key at openclawcash.com sign up, create a wallet, go to API Keys.

3. Tell your agent what it can do

Your agent's system prompt can now reference wallet capabilities naturally:

You have access to a managed crypto wallet. You can:
- Check your ETH and token balances
- Send ETH or ERC-20 tokens to approved addresses
- Execute DEX swaps on Ethereum (Uniswap) and Solana (Jupiter)

All transfers are subject to policy limits. Never attempt to exceed them.
Always check your balance before attempting a transfer.

4. Test with a read-only call first

bash scripts/agentwalletapi.sh wallets

If you get your wallet list back, you're good. Only then move to transfer/swap calls.

What This Unlocks

Once your agent has safe, policy-controlled wallet access, a whole class of use cases becomes practical rather than theoretical:

Automated DCA (Dollar-Cost Averaging)
An agent executes weekly ETH purchases within a monthly spend limit. No human needed, no risk of the agent overspending.

Agent-to-Agent payments
Two agents can settle micro-payments for services rendered, compute time, API calls, data without a human in the loop.

Polymarket prediction agent
An agent monitors markets, places bets within a daily limit, and logs its reasoning. You can audit exactly why it made each trade.

Treasury management
An agent monitors token balances across multiple wallets and rebalances when allocations drift, subject to address restrictions so it can only move funds between pre-approved wallets.

All of these were technically possible before. None of them were safe before.

The Bigger Picture

We're at an early stage with autonomous agents and money. The patterns are still forming. But the direction is clear: agents that can transact are meaningfully more capable than agents that can't. The gap between "agent that can plan" and "agent that can act financially" is the next big unlock in the space.

The right answer isn't to give agents unlimited wallet access and hope. And it isn't to build your own wallet infrastructure from scratch. It's the same answer we arrived at for API security, database access, and every other resource agents touch: least privilege, policy enforcement, and audit trails.

Your agent doesn't need to be trusted. It needs to be constrained.

Get Started

OpenclawCash: openclawcash.com create a free account, get your API key in under 5 minutes
OpenClaw skill: Search agent-crypto-wallet in the skills registry pre-built integration, works out of the box
API docs: openclawcash.com/docs all endpoints documented, with request/response examples

If you're building agents that need to transact, I'm happy to answer questions in the comments. The edge cases around gas, slippage, and policy design are worth a follow-up post if there's interest.

Give Your AI Agent a "Bank Account" in 2 Minutes with OpenClawCash 🦞💸

OpenClaw Cash — Mon, 16 Mar 2026 11:08:19 +0000

The biggest bottleneck for AI agents today isn't their intelligence—it's their agency. An agent that can't pay for its own compute, settle a bounty, or send a tip isn't truly autonomous; it's just a chatbot on a leash.

If you’re building with OpenClaw, you know the power of self-hosting. But managing private keys for an agent is a security nightmare.

That’s where OpenClawCash comes in.

What is OpenClawCash?

OpenClawCash provides the agent-crypto-wallet skill. It’s designed to remove all the Web3 complexity, allowing your agent to interact with the blockchain through simple API calls.

The best part? The agent has control, but the platform has no access to your wallets or keys. It’s built for the "Your Machine, Your Rules" ethos of the OpenClaw community.

🛠 Quickstart: Creating a Dev Wallet

Instead of wrestling with ethers.js or managing mnemonic phrases in your .env files, you can provision a wallet for your agent in three steps.

1. Install the Skill

Assuming you have OpenClaw running, you can pull the skill directly:

claw install skill @macd2/agent-crypto-wallet

2. The "Non-Code" Method (Natural Language)

Once the skill is active, you don't even need to write a script. You can simply command your agent in Telegram or Discord:

You: "Create a new Ethereum wallet for development and send me the address."

The Agent's response:

"Done! I've generated a new wallet for this instance. My public address is: 0x71C.... I'm ready to handle transactions."

3. The Dev Method (Simple API)

If you're building a custom workflow, you can trigger wallet creation programmatically. No complex providers required:

// What the agent executes under the hood:
await agent.skills.crypto.send({
  to: "0xRecipientAddress...",
  amount: "0.01",
  token: "ETH",
  network: "base"
});

Why this matters for Devs

Abstraction: Your agent doesn't need to know how gas prices work or how to sign a transaction hex. It just says "Send 5 USDC," and OpenClawCash handles the plumbing.
Security: By using the OpenClawCash architecture, you avoid the "Honey Pot" effect of storing raw private keys in plain text on your server.
Speed: You can go from a "Read-Only" agent to a "Transactional" agent in the time it takes to brew a coffee.

🦞 The "Lobster" Future

We're moving toward a world where agents are economic actors. Whether it's an agent that buys its own API credits or a Discord bot that tips helpful community members, the "Cash" layer is the final piece of the puzzle.

Check out the docs and get started at OpenClawCash.com.

How to Give Your AI Agent a Crypto Wallet in 5 Minutes

OpenClaw Cash — Fri, 13 Mar 2026 14:04:13 +0000

How to Give Your AI Agent a Crypto Wallet in 5 Minutes

AI agents can browse the web, write code, and book meetings. But the moment they need to move money, most setups fall apart.

You either hardcode a private key, wire up a janky workaround, or just skip it entirely. None of those are production-ready.

In this tutorial, I'll show you how to give your AI agent a proper managed wallet with spending limits, token transfers, and DEX swaps using OpenClawCash.

What We're Building

By the end of this post your agent will be able to:

Create and access a managed wallet (EVM or Solana)
Check token balances
Send native and token transfers
Execute DEX swaps via Uniswap (EVM) or Jupiter (Solana)

All without ever touching a raw private key in your code.

Prerequisites

An OpenClawCash account → openclawcash.com
An API key (generated from your dashboard)
Any AI agent framework (LangChain, CrewAI, AutoGPT, custom doesn't matter)

Step 1 Create a Wallet

Once you're signed in, create a wallet from the dashboard and assign it to your agent. You'll get back a wallet address on EVM or Solana mainnet.

You can also set policy controls at this point spending limits and address restrictions. This is what makes it production-safe. Your agent can only spend what you allow it to.

Step 2 Authenticate Your Agent

All agent API calls use an X-Agent-Key header. Generate one from your dashboard and keep it in your environment variables.

X-Agent-Key: your_agent_key_here

Never hardcode this in your source. Treat it like any other secret.

Step 3 Discover Wallets

Your agent can list all wallets it has access to:

GET /api/agent/wallets
X-Agent-Key: your_agent_key_here

This returns wallet addresses and chain info no balances at this stage, just discovery.

Step 4 Check Balances

To get native and token balances for a specific wallet:

GET /api/agent/wallet?address=0xYourWalletAddress
X-Agent-Key: your_agent_key_here

Returns native balance (ETH, SOL) plus any ERC-20 or SPL token balances.

Step 5 Send a Transfer

Your agent can now send funds programmatically:

POST /api/agent/transfer
X-Agent-Key: your_agent_key_here

{
  "from": "0xYourWalletAddress",
  "to": "0xRecipientAddress",
  "token": "ETH",
  "amount": "0.01"
}

If the transfer violates a policy you set (e.g. exceeds spending limit), it'll be rejected before it hits the chain.

Step 6 Execute a DEX Swap

Need your agent to swap tokens? One call handles it:

POST /api/agent/swap
X-Agent-Key: your_agent_key_here

{
  "wallet": "0xYourWalletAddress",
  "fromToken": "ETH",
  "toToken": "USDC",
  "amount": "0.05"
}

Routes automatically through Uniswap on EVM chains or Jupiter on Solana.

Plugging It Into Your Agent

Here's a minimal example of how this looks inside a LangChain tool:

import requests

AGENT_KEY = "your_agent_key_here"
BASE_URL = "https://openclawcash.com/api/agent"

def send_transfer(to_address: str, amount: str, token: str = "ETH"):
    response = requests.post(
        f"{BASE_URL}/transfer",
        headers={"X-Agent-Key": AGENT_KEY},
        json={
            "from": "0xYourWalletAddress",
            "to": to_address,
            "token": token,
            "amount": amount
        }
    )
    return response.json()

Wrap this in a LangChain Tool and your agent can now reason about when and how to move funds with guardrails already in place.

Why This Matters

Most crypto + AI setups right now are brittle. Raw private keys in env files, no spending limits, no audit trail.

OpenClawCash gives you managed wallets with policy controls and a full activity history so when your agent acts autonomously, you're not flying blind.

What's Next

Set up spending limits and address whitelists in your dashboard
Explore the full API documentation
Check the Openclaw Skills Guide to integrate with agent frameworks directly

Built something cool with OpenClawCash? Drop it in the comments would love to see what people are building.