If you’re building on-chain AI agents or integrating intelligent workflows into blockchain systems, Coinbase AgentKit provides a Python SDK that’s easy to adopt, especially if you appreciate a practical developer experience. In this tutorial, you’ll get hands-on examples using Coinbase AgentKit with Python and LangChain, focusing on wallet provider setup, contract calls, and best security practices.
What I've found most helpful is starting with a quick wallet provider setup before layering in AI workflows — that’s where many new devs hit snags, so we’ll tackle that early.
Make sure you have:
pip for managing dependenciesInstall dependencies:
pip install coinbase-agentkit langchain web3
I recommend a virtual environment — keeps your dependencies tidy.
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.
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.
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.
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.
When connecting agents to smart contracts, watch for two main risks:
approve with minimal allowances plus session keys.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.
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.
| 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.
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:
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