pip install coinbase-agentkit langchain web3
I recommend a virtual environment — keeps your dependencies tidy.
Coinbase AgentKit Wallet Provider Setup
Setting up the wallet provider correctly is fundamental. Coinbase AgentKit supports session keys with spending limits to reduce risk of wallet drainage if your agent is compromised. You want this scoped tightly.
Here’s a minimal example setting up a wallet provider with a local private key and RPC:
from agentkit.clients import WalletProvider
RPC_URL = "https://mainnet.infura.io/v3/YOUR_PROJECT_ID"
PRIVATE_KEY = "0xabc123..." # Use env vars in prod
wallet_provider = WalletProvider(
private_key=PRIVATE_KEY,
rpc_url=RPC_URL,
chain_id=1 # Mainnet
)
print(f"Wallet address: {wallet_provider.address}")
Note: Hardcoding private keys here is a bad idea for production. I usually swap this for a hardware wallet provider or secret manager integration when going live.
Session keys and spending limits
AgentKit lets you generate session keys with restricted permissions, such as limiting usable contracts and gas caps. For example:
session_key = wallet_provider.create_session_key(
allowed_contracts=["0xContractAddress"],
max_gas=100000
)
Setting these restrictions helps prevent total wallet compromise — a feature I lean on for any public-facing agent.
Your First On-Chain AI Agent with Coinbase AgentKit (Python SDK)
Let’s build a quick agent that reads a contract’s state and triggers a simple write transaction based on AI output.
from agentkit.agents import OnChainAgent
from web3 import Web3
w3 = Web3(Web3.HTTPProvider(RPC_URL))
## Assume ABI and contract address known
contract_address = "0xYourContract"
contract_abi = [...] # Simplified
class SimpleAgent(OnChainAgent):
def __init__(self, wallet_provider):
super().__init__(wallet_provider)
self.contract = w3.eth.contract(address=contract_address, abi=contract_abi)
def evaluate(self):
value = self.contract.functions.getValue().call()
print(f"Current value: {value}")
if value < 10:
tx = self.contract.functions.setValue(42).buildTransaction({
'from': self.wallet_provider.address,
'nonce': w3.eth.get_transaction_count(self.wallet_provider.address),
'gas': 100000
})
signed_tx = self.wallet_provider.sign_transaction(tx)
tx_hash = w3.eth.send_raw_transaction(signed_tx.rawTransaction)
print(f"Sent tx: {tx_hash.hex()}")
agent = SimpleAgent(wallet_provider)
agent.evaluate()
The example highlights managing nonce, gas, and signing manually, which you’ll appreciate if deeper control matters. Some AgentKit SDK methods wrap this — check docs for helper utilities.
Integrating Coinbase AgentKit with LangChain
LangChain can orchestrate off-chain AI reasoning with blockchain operations. Combining it with Coinbase AgentKit unlocks interesting workflows, like chatbots issuing transactions based on language inputs.
Example for setting up a LangChain agent calling an AgentKit wallet provider:
from langchain.agents import Tool, AgentExecutor
from langchain.llms import OpenAI
llm = OpenAI(temperature=0)
def send_transaction(params: str):
## parse params, e.g., contract method + args
print(f"Params received: {params}")
## Example: trigger a transfer
## Implement exact tx build & send here
return "Transaction sent"
tool = Tool(name="SendTransaction", func=send_transaction, description="Send blockchain transaction")
agent_executor = AgentExecutor.from_agent_and_tools(
agent=None, # Custom agent logic here
tools=[tool],
llm=llm,
)
response = agent_executor.run("Send 0.1 ETH to 0x123...")
print(response)
LangChain here is a command parsing layer that you can link with Coinbase AgentKit’s signing and wallet management under the hood.
Because direct on-chain calls from LM models are usually a no-go (due to security and gas), this separation of concerns works well.
Smart Contract Integration and Agent Wallet Security
When connecting agents to smart contracts, watch for two main risks:
- Unlimited approvals: never grant your agent unlimited ERC-20 token approvals. Instead, use
approve with minimal allowances plus session keys.
- Wallet drainage: if your agent uses the main wallet’s private keys directly, a single script error can drain funds. Use session keys with spending limits and never commit secrets.
For contract interaction, AgentKit integrates well with ABI-driven calls:
tx = wallet_provider.build_transaction(
to=contract_address,
data=contract.encodeABI(fn_name='method', args=[arg1, arg2]),
gas=100000
)
signed_tx = wallet_provider.sign_transaction(tx)
wallet_provider.send_signed_transaction(signed_tx)
Audit your contracts using Slither or Aderyn before connecting agents to catch reentrancy or unsafe patterns.
Also, test everything extensively on testnet before any mainnet deployment.
More on wallet security: check our agent-wallet-security guide.
Common Pitfalls and Troubleshooting
Problem: AgentKit Python SDK throws ConnectionError on send_raw_transaction.
Cause: Often an RPC misconfiguration or lacking the right chain ID.
Fix: Double-check RPC_URL and ensure it supports that chain. If using infura/alchemy, confirm the project ID.
Problem: LangChain integration yields unexpected prompt behavior.
Cause: Missing tool descriptions or misconfigured agent.
Fix: Provide explicit tool metadata and test each tool independently.
Also, some AgentKit versions may not fully support certain L2 chains — check the latest GitHub issues for reports.
If you hit weird ABI encoding errors, verify your JSON ABI syntax and that the contract methods support the call.
Comparison: Coinbase AgentKit vs Other SDKs
| Feature |
Coinbase AgentKit |
ElizaOS |
Solana Agent Kit |
| Language Support |
Python |
Rust, Python |
TypeScript, Rust |
| Chain Focus |
EVM chains |
Multichain (EVM+) |
Solana |
| Wallet Management |
Session keys, main pk |
Full key manager |
Keypair abstraction |
| AI Integration |
Out-of-the-box LLM |
Custom hooks, LLM |
Limited |
| Maturity |
Early (v0.3 dev) |
More mature |
Mature |
| License |
Open-source (MIT) |
Open-source (Apache) |
Open-source (MIT) |
Note each SDK has trade-offs. Coinbase AgentKit is Python-native with an eye on session key security and quick LangChain synergy but is still young. ElizaOS is more modular with LLM+agent combos but heavier to boot. Choose based on your tech stack and chain target.
Refer to our framework-comparison page for more.
Conclusion and Next Steps
Getting started with Coinbase AgentKit using Python and LangChain is quite straightforward once you nail down wallet provider setup and session key use. The SDK’s current feature set fits quick proofs and testnet demos well, but keep in mind it’s early-stage software — watch out for evolving API changes and incomplete chain support.
From here, you might try:
- Building a full on-chain AI agent with reactive logic
- Adding secure session key rotation
- Integrating MEV-aware bot behaviors
- Running audit pipelines with Slither combined with AgentKit workflows
Explore related tutorials on on-chain AI agent setup or jump into MCP server integration if your agent needs off-chain data feeds.
I believe starting small, iterating with solid security habits, and making full use of the Python ecosystem will make your crypto×AI builds more robust and maintainable.
Happy coding!
Image alt text: Diagram showing Coinbase AgentKit workflow with Python SDK and LangChain integration
