Your AI agent can analyze markets, generate trading strategies, and even write smart contracts. But can it actually execute those trades? Most AI frameworks hit a wall when it comes to blockchain interactions—until now.
Why AI Agents Need Wallet Infrastructure
AI agents are getting incredibly sophisticated. They can research DeFi protocols, identify arbitrage opportunities, and build complex trading strategies. But there's always been a gap: the moment they need to actually interact with money, they're stuck.
Traditional solutions require agents to manage private keys directly (dangerous), rely on external wallet APIs (centralized), or ask humans to manually execute every transaction (defeats the purpose). What's needed is a secure, self-hosted wallet service that agents can integrate with—regardless of which AI framework you're using.
OpenClaw: 17 Tools for Any AI Framework
WAIaaS solves this with OpenClaw, a plugin that provides 17 sessionAuth tools specifically designed for AI agent integration. While WAIaaS has native MCP integration with 45 tools for Claude, OpenClaw brings the core wallet functionality to any AI framework—LangChain, CrewAI, AutoGPT, or custom agent implementations.
Here are the 17 OpenClaw tools available for your agents:
Wallet Management Tools
get-balance — Check wallet's native token balance
get-address — Get wallet's public address
get-assets — List all token balances
get-wallet-info — Complete wallet information
Transfer Operations
send-token — Send native tokens or SPL/ERC-20 transfers
transfer-nft — Send NFTs (ERC-721/ERC-1155 on EVM, Metaplex on Solana)
approve-token — Approve token spending for DeFi protocols
DeFi Integration
get-defi-positions — View lending positions, staking rewards, liquidity pools
execute-action — Execute DeFi operations across 15 integrated protocols
get-health-factor — Monitor lending health across Aave, Compound, etc.
Transaction Management
sign-transaction — Sign arbitrary blockchain transactions
simulate-transaction — Dry-run transactions before execution
get-transaction — Query transaction status and details
list-transactions — Get transaction history
Advanced Features
x402-fetch — HTTP requests with automatic micropayments
sign-message — Sign arbitrary messages for authentication
get-policies — Check active spending limits and restrictions
Quick Integration Example
Here's how to integrate OpenClaw tools with a Python AI agent:
import requests
from typing import Dict, Any
class WAIaaSTools:
def __init__(self, base_url: str, session_token: str):
self.base_url = base_url
self.headers = {"Authorization": f"Bearer {session_token}"}
def get_balance(self) -> Dict[str, Any]:
"""Get wallet balance - core tool for any trading agent"""
response = requests.get(f"{self.base_url}/v1/wallet/balance", headers=self.headers)
return response.json()
def send_token(self, to: str, amount: str, token: str = None) -> Dict[str, Any]:
"""Send tokens - essential for executing trades"""
payload = {"type": "TRANSFER", "to": to, "amount": amount}
if token:
payload["type"] = "TOKEN_TRANSFER"
payload["token"] = token
response = requests.post(f"{self.base_url}/v1/transactions/send",
json=payload, headers=self.headers)
return response.json()
def execute_defi_action(self, provider: str, action: str, params: Dict[str, Any]) -> Dict[str, Any]:
"""Execute DeFi operations - swap, lend, stake, etc."""
response = requests.post(f"{self.base_url}/v1/actions/{provider}/{action}",
json=params, headers=self.headers)
return response.json()
# Usage in your AI agent
tools = WAIaaSTools("http://127.0.0.1:3100", "wai_sess_your_token_here")
# Agent can now check balance
balance = tools.get_balance()
print(f"Agent wallet: {balance['balance']} {balance['symbol']}")
# And execute DeFi operations
swap_result = tools.execute_defi_action("jupiter-swap", "swap", {
"inputMint": "So11111111111111111111111111111111111111112", # SOL
"outputMint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", # USDC
"amount": "1000000000" # 1 SOL
})
LangChain Integration Example
For LangChain users, OpenClaw tools can be wrapped as LangChain tools:
from langchain.tools import Tool
from langchain.agents import initialize_agent, AgentType
from langchain.llms import OpenAI
def create_waiaas_tools(waiaas_client):
return [
Tool(
name="check_wallet_balance",
description="Get the current wallet balance",
func=lambda x: waiaas_client.get_balance()
),
Tool(
name="send_tokens",
description="Send tokens to an address. Input: 'address,amount'",
func=lambda x: waiaas_client.send_token(*x.split(','))
),
Tool(
name="swap_tokens",
description="Swap tokens on Jupiter DEX. Input: 'input_token,output_token,amount'",
func=lambda x: waiaas_client.execute_defi_action("jupiter-swap", "swap", {
"inputMint": x.split(',')[0],
"outputMint": x.split(',')[1],
"amount": x.split(',')[2]
})
)
]
# Initialize agent with wallet tools
llm = OpenAI(temperature=0)
waiaas_tools = create_waiaas_tools(WAIaaSTools(base_url, token))
agent = initialize_agent(waiaas_tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION)
# Agent can now execute: "Check my balance and swap 0.1 SOL for USDC"
response = agent.run("Check my balance and if I have more than 0.1 SOL, swap it for USDC")
Session-Based Security
OpenClaw tools use WAIaaS's session authentication system. Each AI agent gets a dedicated session with configurable permissions and spending limits:
# Create a session for your AI agent (requires master password)
curl -X POST http://127.0.0.1:3100/v1/sessions \
-H "Content-Type: application/json" \
-H "X-Master-Password: your-master-password" \
-d '{
"walletId": "your-wallet-uuid",
"ttl": 86400,
"maxRenewals": 30,
"absoluteLifetime": 2592000
}'
The session token (starting with wai_sess_) is what your AI agent uses for all operations. Sessions can be configured with spending limits, token whitelists, and time restrictions through WAIaaS's 21 policy types.
Multi-Chain Support
Your agents can work across 18 networks spanning Ethereum, Solana, Polygon, Arbitrum, and more. The same OpenClaw tools work regardless of the underlying blockchain:
# Works on Solana
solana_swap = tools.execute_defi_action("jupiter-swap", "swap", {...})
# Same interface on Ethereum
ethereum_swap = tools.execute_defi_action("zerox-swap", "swap", {...})
# Or cross-chain bridging
bridge_tx = tools.execute_defi_action("lifi", "bridge", {
"fromChain": "ethereum",
"toChain": "polygon",
"fromToken": "USDC",
"toToken": "USDC",
"amount": "100000000"
})
Getting Started in 5 Minutes
Install WAIaaS daemon:
npm install -g @waiaas/cli
waiaas init && waiaas start
Create a wallet and session:
waiaas wallet create --name "agent-wallet" --chain solana
# Note the wallet ID from output
waiaas session create --wallet-id <wallet-id>
# Note the session token from output
Fund your wallet with some tokens for testing (send SOL/ETH to the wallet address)
Test the integration:
tools = WAIaaSTools("http://127.0.0.1:3100", "wai_sess_your_token")
print(tools.get_balance())
Integrate with your AI framework using the patterns shown above
Advanced Capabilities
Beyond basic transfers, your agents can access sophisticated DeFi operations through WAIaaS's 15 integrated protocols:
Lending & Borrowing: Aave, Compound integration with health factor monitoring
DEX Trading: Jupiter (Solana), 0x Protocol (EVM) with slippage protection
Liquid Staking: Lido (Ethereum), Jito (Solana) for yield generation
Cross-chain: LI.FI and Across for bridging between networks
Perpetual Futures: Hyperliquid integration with position management
Prediction Markets: Polymarket for betting on future events
Each protocol is accessible through the same execute_defi_action interface, making it easy for agents to compose complex strategies.
Why OpenClaw vs Native MCP?
While WAIaaS provides 45 native MCP tools for Claude Desktop integration, OpenClaw's 17 tools focus on the core wallet operations that any AI agent needs:
Framework Agnostic: Works with LangChain, CrewAI, AutoGPT, custom agents
Lightweight: 17 focused tools vs 45 comprehensive MCP tools
REST-based: Simple HTTP integration, no stdio transport needed
Self-contained: No additional dependencies or configuration files
For Claude users, the native MCP integration provides the best experience. For everything else, OpenClaw is your bridge to wallet functionality.
Ready to give your AI agents financial superpowers? Check out the .
For more advanced integration patterns, see .
Your AI agents are about to become a lot more interesting. Time to let them loose in DeFi.
SOCIAL SHARE CARD GENERATOR