← Back to Guides · Day 20 · 15 min read

How to Build an AI Trading Agent

I built an AI agent that monitors X for signals and trades crypto perps on Aster DEX. Here's exactly how to build one yourself.

Why I built this

I was sitting at my desk watching X, watching charts, checking funding rates, switching between three browser tabs, trying to decide whether to short HOLO or wait for confirmation. By the time I made the decision, the move was already halfway done.

This happens every single time. The signal is there. The analysis takes too long. The execution comes late. And you sit there afterwards thinking "I knew it."

So on Day 20 I decided to build a system that doesn't hesitate.

The signal is there. The analysis takes too long. The execution comes late. And you sit there afterwards thinking "I knew it."

• • •

What the system does

The pipeline has four stages. Every 30 minutes, it runs automatically.

Stage 1: Signal Collection. The agent monitors X using bird CLI. It watches for keywords related to the assets I'm tracking — BTC, ETH, SOL, HOLO, ASTER. But not just any mention. It filters for breaking news, major developments, funding rate shifts, and whale activity. Random noise gets discarded.

Stage 2: AI Analysis. Each signal gets analyzed for sentiment, urgency, and confidence. The AI checks: is this actually actionable? Does the funding rate support this direction? Is there confluence from multiple sources? Only signals above 70% confidence move to the next stage.

Stage 3: Trade Execution. If a signal passes analysis, the system executes on Aster DEX via the MCP server. It calculates position size based on risk parameters, sets leverage, and opens the trade. Currently running in simulated mode — tracking virtual positions with real prices.

Stage 4: Dashboard. Everything feeds into a live dashboard showing open positions, P&L, the signal feed, and system status. Static HTML, refreshed every 30 minutes, hosted on Cloudflare Pages.

• • •

What you'll need

I'm going to walk through exactly what I used. You can swap pieces out, but this is the stack that works.

A VPS. I use Hetzner — the CX22 at €6/month. Any Linux server with 2GB RAM is fine. You need something that runs 24/7 because the pipeline runs on a schedule.

OpenClaw. This is the AI agent framework that ties everything together. It handles the scheduling, the AI calls, the Telegram notifications, and the tool orchestration. Free, open source.

Aster MCP. The Model Context Protocol server for Aster DEX. This is what lets your AI agent actually place orders, check balances, and manage positions on the exchange. Think of it as the API translator between your agent and the exchange.

Bird CLI. For monitoring X without paying for the API. Uses browser cookies. Free.

Total cost: €6/month for the VPS. Everything else is free.

• • •

Step 1 — Set up your VPS

If you don't have a VPS yet, get one. I covered this in the VPS Setup Guide but the short version is: Hetzner CX22 (€6/month), Ubuntu, SSH keys, done. If you want to lock it down properly, follow the Security Checklist after setup.

Once you're SSH'd in:

sudo apt update && sudo apt upgrade -y
sudo apt install -y python3 python3-pip nodejs npm git
• • •

Step 2 — Install OpenClaw

If you already have OpenClaw running, skip this. If not:

curl -fsSL https://openclaw.ai/install.sh | bash
openclaw onboard --install-daemon

This gives you a running AI agent with Telegram integration. If you're completely new to OpenClaw, read What Is an Agent? first. For making your agent actually remember things, see Your Agent Is Only As Good As Its Memory.

• • •

Step 3 — Install Aster MCP

The MCP server is the bridge between your agent and the exchange. Install it:

pip install git+https://github.com/asterdex/aster-mcp.git

Now configure it with your API keys. Go to your Aster DEX account settings, create an API key, and whitelist your VPS IP address. Then:

python3 -c "
from aster_mcp.config import ConfigManager
cm = ConfigManager()
cm.add_account(
    account_id='main',
    api_key='YOUR_API_KEY_HERE',
    api_secret='YOUR_API_SECRET_HERE'
)
print('Account configured.')
"

Test the connection:

aster-mcp test main
# Should output: ✓ Connection successful

If this fails, check that your VPS IP is whitelisted in Aster's API settings. This is always the first thing people miss.

• • •

Step 4 — Install Bird CLI

Bird lets you search X without the paid API. It authenticates via browser cookies.

npm install -g @gloth/cli
bird check

If bird check passes, you're good. If not, you need to export your X cookies. See the bird CLI docs for setup.

• • •

Step 5 — Build the project structure

Create the workspace:

mkdir -p ~/aster-pilot/{scripts,config,data,logs,ui}

Create your strategy config at config/strategy.json:

{
  "symbols": ["BTCUSDT", "ETHUSDT", "SOLUSDT", "HOLOUSDT", "ASTERUSDT"],
  "strategy": {
    "max_leverage": 10,
    "min_confidence": 0.7,
    "max_position_size": 0.01,
    "signals_to_watch": [
      "breaking news crypto",
      "Aster DEX", "$ASTER",
      "AI crypto news", "AI agent",
      "BTC breaking", "ETH breaking",
      "market crash", "market pump",
      "Fed rate", "CPI data"
    ]
  },
  "risk_limits": {
    "max_open_positions": 3,
    "max_daily_trades": 5
  },
  "execution": {
    "live_trading": false
  }
}

Note: live_trading: false. This means the system tracks virtual positions with real prices. Do not change this until you've watched the system run for at least a week.

• • •

Step 6 — The signal collector

This script searches X for relevant signals. The key insight: don't search for everything. Search for breaking news, not mentions. Filter aggressively.

# scripts/signal-collector.py
# Uses bird CLI to search X for trading-relevant signals
# Filters out noise: only keeps actual news content
# Saves to data/signals.json

The full script is available in the Aster Skills Hub. Copy it, read through it, understand what each function does before running it.

• • •

Step 7 — The analyzer

This is where the AI actually thinks. Each signal from the collector gets analyzed for:

  • Sentiment: bullish, bearish, or neutral
  • Confidence: 0 to 1 (only act above 0.7)
  • Urgency: is this time-sensitive?
  • Suggested action: long, short, or skip

The analyzer also checks the current funding rate on Aster. If you're going long but funding is heavily positive, that's a red flag. The AI factors this in.

• • •

Step 8 — The executor

When the analyzer says "go," the executor opens the position on Aster DEX:

# Fetching real price from Aster API
from aster_mcp.client import AsterClient
from aster_mcp.config import ConfigManager

cm = ConfigManager()
account = cm.get_account("main")
client = AsterClient(
    api_key=account['api_key'],
    api_secret=account['api_secret']
)

# Get current price
price_data = client.get_symbol_price("HOLOUSDT")
current_price = float(price_data['price'])

# Create order (when live_trading is true)
# client.create_order(
#     symbol="HOLOUSDT",
#     side="SELL",
#     type="MARKET",
#     quantity=calculated_qty
# )

Always fetch real prices from the API. Never hardcode prices or use fallbacks. I learned this the hard way on Day 19.

• • •

Step 9 — The dashboard

The dashboard is a single HTML file that reads from a data.json file. No backend, no WebSocket, no complexity. Just static HTML that gets republished every 30 minutes.

Deploy it to Cloudflare Pages, your VPS nginx, Vercel — anywhere that serves static files. The data file gets regenerated by the pipeline and pushed on each run.

Mine lives at panke.app/projects/aster-pilot/.

• • •

Step 10 — Automate it

The last step is the cron job. In OpenClaw, this is one command:

# Runs every 30 minutes:
# collect signals → analyze → execute → publish → deploy

Once the cron is set, the system runs itself. You check the dashboard when you want to. You get Telegram notifications when something interesting happens. Otherwise, it just works.

• • •

Start with simulation

I cannot stress this enough. Run in simulated mode first. Watch the signals it collects. Read the analysis. Look at what trades it would have made. Are they good? Are they garbage?

The system is only as good as your strategy config. If your keywords are too broad, you get noise. If your confidence threshold is too low, you get bad trades. Tune it by watching.

When you've seen enough good decisions to trust it — then flip the switch.

The system is only as good as your strategy config. Your rules define your results. Start specific, expand carefully.

• • •

What I'd do differently

If I were starting over, I'd spend more time on the signal quality upfront. My first version collected everything — every mention of BTC on X. That's useless. The filtering is everything.

I'd also set up proper P&L tracking from day one. Simulated positions are only useful if you can measure their performance. Build the tracking before you build the executor.

And I'd start with fewer symbols. I began with four. You should start with one. Get the system dialed in for a single asset, then expand.

• • •

The bigger picture

This isn't just about trading. This is about building AI systems that watch, analyze, and act — while you do something else. The same architecture works for monitoring competitors, tracking job markets, watching regulatory changes, anything that requires continuous attention and timely action. If you're looking for what else to build in this space, read What to Build in the Agent Age — it's a list of 14 startup ideas from the smartest investors in tech.

Trading just happens to have the tightest feedback loop. You know within hours if the system made a good call. That makes it the perfect training ground for building autonomous agents.

The system isn't magic. It's a pipeline. You define the rules, the AI executes them. Build slow, build quality, and let the machine do the boring part.