OpenClaw Plugin: Connect WAIaaS to LangChain, CrewAI, and Any AI Framework

WAIaaS released OpenClaw, a plugin that connects AI agent frameworks such as LangChain, CrewAI, and AutoGPT to self-hosted blockchain wallets through five tool categories: wallet, transfer, defi, nft, and utility. The plugin wraps the WAIaaS daemon's wallet infrastructure — key storage, transaction signing, policy enforcement, and multi-chain support — into structured tools agents can call directly, avoiding the need to rewrite agents or build financial plumbing from scratch.

Your AI agent can browse the web, write code, and manage files — but can it swap tokens? The OpenClaw plugin is WAIaaS's answer to that question: a drop-in wallet toolkit that connects your existing AI agent framework to real blockchain wallets, without rewriting your agent from scratch. You've built an agent. Maybe it's a LangChain chain, a CrewAI crew, or something you rolled yourself on top of an LLM API. It can reason, plan, and call tools. But the moment you need it to do anything with money — pay for an API, swap tokens, send funds to a counterparty — you hit a wall. Blockchains don't have a "tool call" interface. Signing a transaction requires private keys, RPC connections, nonce management, gas estimation, and a dozen other things that have nothing to do with your agent's actual job. Most developers either give up, hardcode a single wallet with no security controls, or spend weeks building financial plumbing that isn't their core product. The result is agents that are powerful reasoners but financially stranded. They can think about money, but they can't touch it. WAIaaS is a self-hosted Wallet-as-a-Service daemon — you run it alongside your agent, and it handles all the wallet infrastructure: key storage, transaction signing, policy enforcement, DeFi integrations, multi-chain support. Your agent talks to it over HTTP or through a tool interface. The OpenClaw plugin is specifically designed for agent frameworks. Instead of exposing a raw REST API, it wraps WAIaaS capabilities into structured tools that LangChain, CrewAI, AutoGPT, or any framework that supports tool use can call directly. The plugin exposes 5 tool categories : wallet , transfer , defi , nft , and utility . Each category maps to a natural set of things an agent might need to do in the course of completing a task. Before your agent can use OpenClaw, you need the WAIaaS daemon running. The fastest path is Docker: docker run -d \ --name waiaas \ -p 127.0.0.1:3100:3100 \ -v waiaas-data:/data \ -e WAIAAS AUTO PROVISION=true \ ghcr.io/waiaas/waiaas:latest Grab the auto-generated master password docker exec waiaas cat /data/recovery.key Or if you prefer the CLI: npm install -g @waiaas/cli waiaas init --auto-provision waiaas start waiaas quickset Creates wallets + sessions automatically Either way, you end up with a daemon listening on http://127.0.0.1:3100 and a session token that looks like wai sess eyJhbGciOiJIUzI1NiJ9... . That token is what your agent will use to authenticate. The daemon itself has 39 REST API route modules under the hood, but you won't need to interact with most of them directly — OpenClaw handles that abstraction for you. OpenClaw's 5 tools wallet , transfer , defi , nft , utility each act as a gateway to a category of operations. Your agent calls a tool, passes parameters, and gets back structured results. The daemon handles everything else: signing, broadcasting, confirming. wallet — Query wallet state: address, balances, transaction history, open sessions. transfer — Move assets: native tokens, ERC-20/SPL tokens, NFTs. The daemon's 7-stage pipeline validate → auth → policy → wait → execute → confirm runs in the background, so your agent just submits a transfer and polls for completion. defi — Execute DeFi actions against any of the 15 integrated protocol providers, including Aave v3, Jupiter swap, Lido staking, Jito staking, Hyperliquid, Kamino, Pendle, Polymarket, and others. Your agent doesn't need to know how Jupiter's routing API works — it calls the DeFi tool with intent, and OpenClaw + WAIaaS handles the execution. nft — Read NFT metadata, list holdings EVM ERC-721/ERC-1155 and Solana Metaplex , and transfer NFTs. utility — Supporting operations: encode calldata, resolve assets, check provider status, interact with x402 payment endpoints. Here's what wiring OpenClaw into a LangChain-style agent looks like. First, your agent gets the OpenClaw tools registered as part of its tool set. Then it can call them like any other tool. Before the agent does anything financial, you'll want to verify the wallet is funded and know what it's working with. Using the TypeScript SDK directly which OpenClaw wraps , the pattern looks like this: js import { WAIaaSClient } from '@waiaas/sdk'; const client = new WAIaaSClient { baseUrl: 'http://127.0.0.1:3100', sessionToken: process.env.WAIAAS SESSION TOKEN, } ; // Agent checks its own balance before deciding whether to proceed const balance = await client.getBalance ; console.log Balance: ${balance.balance} ${balance.symbol} ${balance.chain}/${balance.network} ; When the agent decides to execute a transfer, it submits the transaction and polls for confirmation: js const sendResult = await client.sendToken { type: 'TRANSFER', to: 'recipient-address', amount: '0.001', } ; console.log Transaction submitted: ${sendResult.id} status: ${sendResult.status} ; // Poll for confirmation const POLL TIMEOUT MS = 60 000; const startTime = Date.now ; while Date.now - startTime < POLL TIMEOUT MS { const tx = await client.getTransaction sendResult.id ; if tx.status === 'COMPLETED' { console.log Transaction confirmed Hash: ${tx.txHash} ; break; } if tx.status === 'FAILED' { console.error Transaction failed: ${tx.error} ; break; } await new Promise resolve = setTimeout resolve, 1000 ; } The agent doesn't know or care about private keys, RPC nodes, or gas pricing. It submits intent, waits for result. This is worth stopping on, because it's the part most developers skip and later regret. When you give an agent a wallet, you're giving it the ability to move real money. WAIaaS's policy engine is what keeps that from being terrifying. The policy engine has 21 policy types with 4 security tiers: INSTANT execute immediately , NOTIFY execute and alert you , DELAY queue for N seconds, cancellable , and APPROVAL require human sign-off . Policies follow default-deny: if you haven't explicitly allowed something, it's blocked. A sensible starting policy for an agent wallet: curl -X POST http://127.0.0.1:3100/v1/policies \ -H "Content-Type: application/json" \ -H "X-Master-Password: my-secret-password" \ -d '{ "walletId": "<wallet-uuid ", "type": "SPENDING LIMIT", "rules": { "instant max usd": 100, "notify max usd": 500, "delay max usd": 2000, "delay seconds": 900, "daily limit usd": 5000 } }' This single policy means: under $100 goes through immediately, $100–$500 notifies you but proceeds, $500–$2000 waits 15 minutes during which you can cancel , and anything over $2000 requires your explicit approval. Your agent can still operate autonomously for routine tasks, but large moves get human review. You'll also want to add an ALLOWED TOKENS policy so the agent can only move tokens you've explicitly approved, and a CONTRACT WHITELIST if it's going to call DeFi protocols. Without these, those operations are blocked by default — which is the right default. With the defi OpenClaw tool and the 15 protocol providers integrated into WAIaaS, an agent can: PERP MAX LEVERAGE policy The DeFi action call via the REST API looks like this — and OpenClaw wraps this pattern so your agent can invoke it through tool calling: curl -X POST http://127.0.0.1:3100/v1/actions/jupiter-swap/swap \ -H "Content-Type: application/json" \ -H "Authorization: Bearer wai sess <token " \ -d '{ "inputMint": "So11111111111111111111111111111111111111112", "outputMint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", "amount": "1000000000" }' Before any of this executes, the transaction runs through the 7-stage pipeline. Stage 3 is the policy check — if the action violates any configured policy wrong token, too large, wrong network, wrong venue , it gets blocked before any signing happens. Stage 4 handles the delay/approval wait if required. Stage 5 is execution. Your agent waits for the pipeline to complete. If your agent is being cautious or you want to validate a transaction before committing, the dry-run API lets you simulate without executing: curl -X POST http://127.0.0.1:3100/v1/transactions/send \ -H "Content-Type: application/json" \ -H "Authorization: Bearer wai sess <token " \ -d '{ "type": "TRANSFER", "to": "recipient-address", "amount": "0.1", "dryRun": true }' This runs all validation stages and returns what would happen — including policy decisions and estimated outcomes — without touching the chain. Useful for agents that need to reason about feasibility before committing. WAIaaS returns structured errors, which means your agent can make intelligent decisions when something goes wrong rather than just logging an unhandled exception: js import { WAIaaSClient, WAIaaSError } from '@waiaas/sdk'; try { const tx = await client.sendToken { to: '...', amount: '1.0' } ; } catch error { if error instanceof WAIaaSError { console.error API Error: ${error.code} ${error.message} ; // error.code examples: INSUFFICIENT BALANCE, POLICY DENIED, TOKEN EXPIRED } } POLICY DENIED means the agent tried something the policy engine blocked — the agent should not retry, and probably should surface this to the user. INSUFFICIENT BALANCE means the agent needs to either acquire funds or reduce the amount. TOKEN EXPIRED means the session needs to be refreshed by whoever manages sessions typically your orchestration layer, not the agent itself . Structured errors make your agent a better reasoner about financial operations, not just a blind executor. Here's the minimal path to an agent with a wallet: Step 1: Start the daemon npm install -g @waiaas/cli waiaas init --auto-provision && waiaas start Step 2: Create a wallet and session waiaas quickset Step 3: Set a spending policy use the curl example above with your wallet ID and master password Step 4: Install the SDK and connect npm install @waiaas/sdk Then use the WAIaaSClient with your session token as shown in the examples above. Wire the OpenClaw tools into your framework's tool registry, and your agent is financially operational. Step 5: Test with dry run before letting the agent execute live transactions. The OpenClaw plugin is the fastest path to financial capability for an existing agent, but WAIaaS has deeper integrations worth exploring. If you're building for Claude specifically, the MCP integration with 45 tools gives Claude native wallet awareness through the Model Context Protocol. If you need your agent to pay for API calls automatically as part of its workflow, the x402 HTTP payment protocol support handles that transparently. Explore the full codebase at https://github.com/waiaas/WAIaaS https://github.com/waiaas/WAIaaS — the monorepo includes the OpenClaw plugin source, all 15 DeFi provider implementations, and the full test suite 684+ test files so you can see exactly what each integration does before trusting it with funds. For documentation and the hosted reference, visit https://waiaas.ai https://waiaas.ai . Your agent already knows how to think. Now give it a wallet.