A traditional trading bot follows a fixed rule set. An autonomous AI trading agent thinks — reading market data, consulting its own strategy playbook in plain English, reasoning through the setup, and only then deciding whether to trade. We build production-grade autonomous trading agents on top of OpenClaw and Anthropic’s Claude that run 24/7, manage their own positions, and report back to you on Telegram. Here is the architecture, the tech stack, and a real reference build that is live in paper trading right now.
Most retail trading bots are rule-based state machines. If RSI crosses 30, buy. If price hits the take-profit, sell. The logic is hard-coded in Python or Pine Script, and the bot does exactly what it was told — nothing more, nothing less. That works for the simplest strategies, but breaks down the moment you want to bring in nuance: a setup that is technically valid but feels off because of higher-timeframe context, a funding rate divergence that hints at a reversal, or a news catalyst that should pause the system.
An autonomous AI trading agent uses an LLM — Claude or GPT — as the decision engine instead of a hard-coded rule set. The agent reads market data, references its own strategy playbook written in plain English, makes a reasoned trade decision, and executes it. Crucially, the agent has persistent memory: a structured set of markdown files describing its identity, strategy, current positions, and learnings from prior trades. Every decision is informed by the agent’s history, not just the current snapshot.
In our reference build, the Rubicon trading agent runs four independent bots simultaneously, each with its own strategy, its own personality, and its own simulated paper-trading account. The bots scan markets every 5 minutes, hunt for setups that match their playbook, and place trades through the Hyperliquid perpetual futures API. Every trade is announced on Telegram, and a daily P&L summary lands at 8pm CT.
A single bot trading a single strategy is fragile. The strategy works for a regime; when the regime changes, the bot bleeds. The Rubicon system solves this with a four-bot ensemble — each bot runs an independent strategy with its own parameters, its own risk caps, and its own personality. When one strategy stalls, the others keep trading. The combined PnL is far smoother than any single bot’s curve.
Trades funding rate extremes and reverts at support/resistance levels. Balanced risk profile with a $200 max position and 2% stop loss. Catches the calm-before-the-storm setups.
Watches EMA 9/21/50 crossovers, RSI confirmation, and volume expansion to ride trend breakouts aggressively. Higher position size, runs winners.
Fast in, fast out. Bollinger Band touches with VWAP and RSI confirmation. Tighter 1% stops, max 10 trades per day, $150 max position. Quick profit-taking.
Patient bot. Waits for RSI divergences and funding extremes, then fades the move. Max 3 trades per day, 2.5% stops, designed for high win-rate-per-trade rather than frequency.
Each bot has a SOUL.md file describing its strategy in plain English, a TRADE_STATE.md file tracking current positions and balances, and a LEARNINGS.md file where the agent records what it has discovered through paper trading. The bot reads these files at the start of every cycle, references them while making decisions, and updates them after every action. The full state of the bot is human-readable markdown — you can audit any decision by opening a text editor.
The Rubicon agent runs on OpenClaw, an open-source agent framework that handles the LLM loop, scheduled tasks, persistent memory, and tool execution. Anthropic’s Claude is the underlying language model. Hyperliquid is the exchange (chosen for low fees, deep liquidity, and a clean public API). Telegram is the notification rail.
The decision loop is the most important part of an AI trading agent. Every 5 minutes, the agent wakes up via a cron task, reads the current state of the markets, references its own strategy playbook, and decides whether to act. Here is what one cycle looks like for the SCALPER bot:
// Pseudo-code: SCALPER decision cycle (runs every 5 minutes)
async function scalperCycle() {
// 1. Read agent's own playbook + state
const soul = await readMarkdown('agents/scalper/SOUL.md');
const state = await readMarkdown('agents/scalper/TRADE_STATE.md');
// 2. Pull live market data
const markets = await hyperliquid.getMarketSnapshots(['BTC', 'ETH', 'SOL']);
// 3. Ask Claude: given my soul + state + markets, what do I do?
const decision = await claude.messages.create({
model: 'claude-opus-4-7',
system: soul,
messages: [
{ role: 'user', content: `Current state:\n${state}\n\nMarkets:\n${markets}` }
],
tools: [placeOrder, closePosition, updateState, sendTelegram]
});
// 4. Execute whatever tools Claude called
await executeTools(decision.toolCalls);
// 5. Append the reasoning to LEARNINGS.md for future cycles
await appendLearnings(decision.reasoning);
}Notice the elegance: the agent’s strategy lives in plain English in SOUL.md, the agent’s memory lives in plain English in TRADE_STATE.md, and the LLM reasons through the decision in plain English. There is no opaque neural net — you can read every decision the agent has ever made, because every reasoning step is logged. This is a level of auditability that no traditional algo trading shop can match.
The most common objection to AI trading agents is “what if it goes rogue?” The answer is hard-coded risk caps that exist outside the LLM’s reach. The agent’s tools enforce limits. If the LLM tries to place a $5,000 position when the cap is $200, the tool returns an error and the agent moves on. If the LLM tries to use 20x leverage when the cap is 5x, the tool refuses. The agent cannot override the rails — only adapt within them.
Per-bot caps (e.g., $200 for ATLAS, $150 for SCALPER). Enforced inside the order tool. The LLM cannot place bigger positions than the configured cap, period.
$80-$100 per bot. Once hit, the bot stops opening new positions until the next day’s reset. Existing positions remain managed; new entries are blocked.
Stop loss orders are placed on Hyperliquid itself, not held in the agent’s memory. If the agent crashes mid-trade, the stop still triggers. Defense in depth.
SCALPER capped at 10 trades/day, CONTRARIAN at 3. Prevents over-trading or runaway loops if the strategy logic ever breaks down.
Paper trading first: Every Rubicon agent ships in paper trading mode by default. We require a minimum of 1-2 weeks of paper trading before any live capital touches the system. This catches strategy bugs, prompt regressions, and exchange API edge cases without risking real money.
Trading agents that run silently are agents you cannot trust. Every Rubicon bot reports to a shared Telegram chat with a unique prefix (“MOMENTUM BOT”, “SCALPER BOT”, etc.) for every notable action. You see entries, exits, partial closes, daily P&L summaries, and any errors in real time on your phone — whether you’re at the desk or sitting on a beach.
Instant Telegram message when any bot opens a position: bot name, side, size, entry price, stop loss, take profit, and the reasoning behind the decision.
When a position closes, Telegram fires a message with realized PnL in dollars and percent, hold time, and updated balance. Never wonder “did the bot close that?”
A scheduled cron task fires a per-bot summary every evening: trades taken, win rate, daily PnL, current open positions. Roll up across all four bots.
Any uncaught exception, API error, or risk-cap violation pings Telegram immediately. You know the second something goes sideways — not the next morning.
One of the most powerful features of the autonomous agent architecture is structured persistent memory. Every bot has a LEARNINGS.md file where it appends discoveries from prior trades: which setups have been working, which have been failing, which times of day have been profitable, and any market regime observations the LLM has reasoned about. On every new cycle, the agent reads its own learnings before making decisions.
This is meaningfully different from a traditional algo bot, which has no memory between cycles other than the open position state. Our autonomous agents compound knowledge over time. After 200 trades, the agent has a written record of what works, what doesn’t, and what context matters — and that record is fed back into every future decision. The bot at trade 500 is operationally more sophisticated than the bot at trade 1.
Audit-friendly by design: Want to know why the bot took a trade three weeks ago? Open the LEARNINGS.md file at that timestamp and read the agent’s own words. Want to know which playbook rule led to a loss? It is logged. This is a level of explainability that is impossible with neural-net-based trading systems.
The Rubicon system is the proof. Here is the menu of capabilities we bring to a custom autonomous AI trading agent project.
Want to combine this with a real-time trading dashboard, a trading platform marketing site, or a fully custom futures trading bot with OCR signal capture? We can ship the entire stack — agent, dashboard, marketing site, Stripe billing, the works. See our full services menu or get in touch.
Whether you want a single agent for personal trading, a multi-bot ensemble for a fund, or a SaaS that licenses AI agents to your community — we can ship it. Call or text (320) 360-8285 to start scoping. DM HUNT for a fixed-quote within 48 hours.