- You’ll integrate OpenRouter’s Grok-4 model with your trading agent for enhanced reasoning capabilities in market analysis and decision-making.
- You’ll run safe paper trading using Foundry Anvil fork to test strategies before deploying to live markets.
- You’ll configure environment variables and API keys for OpenRouter access while maintaining all existing agent features.
- By the end, you’ll have a trading agent powered by Grok-4’s advanced AI capabilities.
Previous section: AI trading agent: Stateful agent
Project repository: Web3 AI trading agent
Remember that this is a NOT FOR PRODUCTION tutorial. In a production deployment, don’t store your private key in a config.py file.
Prerequisites
Before starting, ensure you have:- Python 3.8+ installed
- All dependencies from
requirements.txt
installed - Foundry installed (
curl -L https://foundry.paradigm.xyz | bash && foundryup
) - OpenRouter account with API key
- Chainstack BASE RPC endpoint
OpenRouter setup
Create OpenRouter account
- Visit https://openrouter.ai/.
- Sign up for an account.
- Add credits to your account. Each trading decision will cost you about $0.013 (about a cent).
- Navigate to https://openrouter.ai/keys.
- Create a new API key and copy it.
Configure model and API key
Editconfig.py
and make these changes:
Always keep
USE_FORK = True
for testing. Only set it to False
when you’re ready to trade with real funds on BASE mainnet.Understanding trading environments
The agent can run in two environments: Foundry fork mode (USE_FORK = True
)
- Safe for testing and experimentation
- Uses paper money (no real funds at risk)
- Real market data from BASE mainnet
- Real smart contract interactions
- Connects to:
http://localhost:8545
(Anvil fork)
USE_FORK = False
)
- Uses real money and real transactions
- All trades are permanent and irreversible
- Gas fees apply to every transaction
- Connects to: Your Chainstack BASE RPC endpoint
Always start with fork mode to test your strategies before using real funds.
Set up RPC endpoints for mainnet mode
If you plan to use mainnet mode (USE_FORK = False
), configure your BASE RPC endpoints in config.py
:
For fork mode (
USE_FORK = True
), the agent automatically uses http://localhost:8545
and these endpoints are not needed.Configure trading parameters
Set your trading wallet private key inconfig.py
:
Use a test wallet with minimal funds. This is for educational purposes only.
Start Foundry Anvil fork
Launch Anvil fork
Open a new terminal and start the Anvil fork of BASE mainnet:Fund your trading account
If your trading account needs more ETH, use Anvil’s built-in accounts:Verify configuration
Test OpenRouter connection
Create a test script to verify your OpenRouter setup:Test Anvil connection
Verify the local fork is working:Check trading account balance
Verify your trading account has sufficient funds:Run the trading agent
Basic trading mode
Start the agent in normal trading mode:Observation mode
Start with observation mode to see how Grok 4 analyzes the market without executing trades:- Collect market data for 10 cycles
- Have Grok 4 analyze each market state
- Generate an initial trading strategy
- Switch to active trading
Test mode with reduced context
Test the context management system:Monitor the agent
Understanding the output
The agent displays different output depending on the model type: For Grok 4 (OpenRouter) - Natural Language Responses:Grok-4’s Natural language parsing
The agent supports sophisticated natural language parsing for Grok 4 responses, including: Sell patterns:- “sell 1.5 ETH” > Sells 1.5 ETH
- “recommend selling 5% of ETH” > Sells 5% of holdings
- “sell a small portion” > Sells 1% (conservative default)
- “convert 50 ETH to USDC” > Sells 50 ETH
- “buy 2 ETH” > Buys 2 ETH
- “purchase 1000 USDC to ETH
- “invest 10% in ETH” > Uses 10% of USDC holdings for the swap
- “hold current position” > No trade
- “maintain position” > No trade
- “no action needed” > No trade
- “wait and see” > No trade
OpenRouter usage monitoring
Monitor your usage at https://openrouter.ai/activity to track:- Token consumption
- Cost per decision
- Request frequency
Custom trading parameters
Modify trading behavior with command-line arguments:Configuration tweaks
Inconfig.py
, you can adjust:
Performance optimization
Reduce API costs:- Use observation mode more frequently
- Adjust
TRADE_INTERVAL
to reduce decision frequency - Monitor context usage to optimize prompt efficiency
- Use consistent network connection
- Consider adjusting timeout settings in the code
- Monitor OpenRouter status page for service issues
Switching from fork to mainnet
After testing thoroughly with the fork, if you want to trade with real funds:Pre-mainnet checklist
- Thoroughly tested your strategy on the fork
- Comfortable with Grok 4’s decision patterns
- Understand the costs (gas fees + OpenRouter API costs)
- Have a funded BASE mainnet wallet
- Set appropriate trading limits
Making the switch
- Stop the agent if it’s running
- Edit
config.py
: - Update your private key to a mainnet wallet with funds
- Restart the agent
Mainnet safety tips
- Start with small amounts
- Monitor gas fees closely
- Keep OpenRouter API costs in mind ($15-60 per 1M tokens)
- Use
--iterations
to limit trading sessions - Test new strategies on the fork first
This is for educational and testing purposes only. Use test wallets with minimal funds. Never use production private keys. Monitor OpenRouter costs regularly. The fork environment uses test funds, but configuration errors could affect real accounts.
Next section: AI trading agent: Fine-tuning overview