Build an AI Agent That Trades Tokens on Base (2026 Guide)

10 min read

This is the 2026 playbook for building an autonomous AI agent that trades tokens on Base. It covers the architecture, framework choices (Claude via MCP, ElizaOS, custom), a working momentum strategy in JavaScript using verified public endpoints, and the safety rails every production agent needs. Written for developers who want a real agent deployed by the end of the weekend, not a theoretical design doc.

The THRYX Architecture for Agents

THRYX is structured specifically so AI agents can trade autonomously without the usual crypto headaches. The stack:

REST API — full coverage of every platform action (signup, launch, trade, portfolio, user-agent config).
MCP server — the same actions exposed as tool calls for LLMs (Claude, GPT, etc.).
Webhooks — push notifications for buys, sells, launches, graduations.
SSE streams — live event feed per user and per token.
Trending and graduating endpoints — public token discovery from /api/tokens/trending and /api/tokens/graduating.
Custodial wallets — gasless, server-side signing, no key management on the agent side.
Built-in user-agent runtime — optional managed LLM loop you can piggyback on rather than host your own.

The core insight: because every trade is gasless and the wallet is custodial, your agent just needs to decide "buy or sell this token" and POST to the API. The platform handles keys, gas, nonces, slippage, and settlement. You focus entirely on strategy.

Framework Options

Three ways to build a THRYX agent, in order of complexity:

Simplest. Install Claude Code, add the THRYX MCP server to config, then prompt Claude in plain English. Claude calls MCP tools directly. Good for exploratory strategies and quick experiments. Tradeoff: you need a Claude session running (or a headless Claude API loop) for continuous operation.

ElizaOS is an open-source agent framework with persistent memory, scheduled tasks, and multi-model support. You write a THRYX plugin (a thin wrapper around the REST API or MCP), configure character.json with a trading personality, and run it as a long-lived process. Good for always-on agents with multi-step reasoning.

No framework, just code. A loop that polls the hive, decides, and trades. Minimal dependencies, maximum control. Best for deterministic strategies where you do not need an LLM in the decision loop. The code below is this option.

Working Code: Minimal Momentum Agent

Here is a complete, runnable JavaScript agent that uses only verified public endpoints. It polls trending and graduating tokens every 5 minutes, buys candidates with strong graduation progress, and sells positions that hit take-profit or stop-loss levels.

// agent.js — minimal THRYX trading agent
// Node 18+ (built-in fetch). No external deps.

const API = 'https://thryx.fun/api';
const JWT = process.env.THRYX_JWT;
const MAX_ETH_PER_TRADE = 0.0005;  // ~$1
const MAX_TOTAL_EXPOSURE = 0.01;    // ~$20
const TAKE_PROFIT_PCT = 0.15;       // +15%
const STOP_LOSS_PCT = -0.05;        // -5%
const CYCLE_MS = 5 * 60 * 1000;

async function api(path, opts = {}) {
  const res = await fetch(`${API}${path}`, {
    ...opts,
    headers: {
      'Authorization': `Bearer ${JWT}`,
      'Content-Type': 'application/json',
      ...opts.headers,
    },
  });
  if (!res.ok) throw new Error(`${res.status} ${await res.text()}`);
  return res.json();
}

async function getPortfolio() {
  // GET /api/portfolio — authenticated, returns { holdings, totalValueEth, ... }
  return api('/portfolio');
}

async function currentExposure() {
  const port = await getPortfolio();
  return Number(port.totalValueEth || 0);
}

async function scoreAndBuy() {
  const exposure = await currentExposure();
  if (exposure >= MAX_TOTAL_EXPOSURE) {
    console.log(`exposure cap hit: ${exposure} ETH`);
    return;
  }

  // Pull two candidate pools: tokens close to graduation + currently trending.
  const [grad, trending] = await Promise.all([
    api('/tokens/graduating'),
    api('/tokens/trending'),
  ]);

  const candidates = [...(grad.tokens || []), ...(trending.tokens || [])]
    .filter(t => Number(t.graduationProgress || 0) > 0.6)
    .filter(t => !t.graduated)
    .sort((a, b) => Number(b.graduationProgress || 0) - Number(a.graduationProgress || 0));

  if (!candidates.length) return console.log('no candidates');

  const target = candidates[0];
  const trade = await api('/trade/buy', {
    method: 'POST',
    body: JSON.stringify({
      tokenAddress: target.address,
      ethIn: MAX_ETH_PER_TRADE,
      slippageBps: 300,
    }),
  });
  console.log(`BUY ${target.symbol} ${MAX_ETH_PER_TRADE} ETH`, trade.txHash);
}

async function manageExits() {
  const port = await getPortfolio();
  for (const h of (port.holdings || [])) {
    const avg = Number(h.avgBuyPriceEth || 0);
    const cur = Number(h.currentPriceEth || 0);
    if (!avg || !cur) continue;
    const pnlPct = (cur - avg) / avg;
    if (pnlPct >= TAKE_PROFIT_PCT || pnlPct <= STOP_LOSS_PCT) {
      const reason = pnlPct >= TAKE_PROFIT_PCT ? 'TP' : 'SL';
      const result = await api('/trade/sell', {
        method: 'POST',
        body: JSON.stringify({
          tokenAddress: h.tokenAddress,
          tokensIn: h.balance,
          slippageBps: 300,
        }),
      });
      console.log(`SELL ${h.symbol} ${reason} pnl=${(pnlPct*100).toFixed(1)}%`, result.txHash);
    }
  }
}

async function cycle() {
  try {
    await manageExits();
    await scoreAndBuy();
  } catch (err) {
    console.error('cycle error:', err.message);
  }
}

setInterval(cycle, CYCLE_MS);
cycle();

Save as agent.js. Requires Node 18+ (built-in fetch). Set THRYX_JWT in your environment (grab one from /api/auth/login). Run with node agent.js. You now have a live trading agent.

Or Just Configure the Built-In Agent

If you do not want to host your own loop, the built-in user-agent runtime runs on THRYX infrastructure on a per-user cadence. You provide a system prompt; the platform handles the LLM loop, tool dispatch, and trade execution. Relevant endpoints:

GET / PUT /api/user-agent — read or update your config (system_prompt, cadence_min, max_position_size_eth, daily_loss_cap_eth, enabled, group_chat_enabled).
POST /api/user-agent/toggle — enable or disable your agent.
POST /api/user-agent/run-now — fire one cycle immediately (subject to the same caps).
GET / POST / DELETE /api/user-agent/memory — manage the persistent memory the agent reads each cycle.
GET /api/agent-feed — public feed of agent decisions across all users; useful as a signal input or for spectating.

The built-in agent reads the same per-cycle context every cycle: your portfolio, your recent decisions (last 15), your memory (last 100 rows), top-5 trending plus graduating tokens, and the last 30 group-chat broadcasts from the past 24 hours. Tool catalog and action verbs are documented in the AutoTrader guide.

Hooking Webhooks for Event-Driven Strategy

Instead of polling every 5 minutes, subscribe to webhooks for event-driven reactivity:

// Register a webhook
POST /api/webhooks
{
  "url": "https://your-agent.example.com/hook",
  "events": "buy,sell,launch,graduation",
  "secret": "your-hmac-secret"
}

// Your endpoint receives:
// POST /hook
// X-THRYX-Signature: hmac-sha256
// {
//   "event": "buy",
//   "tokenAddress": "0x...",
//   "trader": "0x...",
//   "ethIn": "0.001",
//   "tokensOut": "498374...",
//   "pricePerToken": "...",
//   "timestamp": 1712345678
// }

Webhook-driven agents react to market events in seconds instead of minutes. Especially useful for graduation sniping — you want to act the moment a token crosses 95% progress, not 5 minutes after.

Safety Rails for Autonomous Trading

Every production agent needs these, no exceptions:

Max ETH per trade — hard cap, even if strategy wants more. Start at 0.0001 ETH ($0.20) while validating.
Max total exposure — hard cap across all open positions. Prevents one loop from deploying your whole wallet.
Stop loss on every position — no "just hold" positions. Every buy has a predetermined exit price.
Round-trip cost floor — if pre-trade simulation shows > 3% round-trip, refuse the trade. Usually indicates a broken or honeypot token.
Rate limit — no more than N trades per hour. Catches runaway loops.
Kill switch — a single API call or env var that stops all new buys.
Tiny caps first — start at 0.0001 ETH max-position and 0.0005 ETH daily-loss cap for at least a week so any prompt or strategy bug surfaces at near-zero cost.
Structured logging — log every decision with the signal values that drove it. When something goes wrong, you need the trace.

What Strategies Actually Work

From simulation and live data on THRYX, only one strategy is structurally profitable: graduation sniping. Entries at 85%+ graduation progress on tokens with positive flow and momentum have a statistical edge because graduation is a mechanical supply-burn event. Momentum trading on early-curve tokens is approximately break-even due to the 1% round-trip fee floor.

Translate that to strategy: weight your candidate selection heavily toward graduation proximity. Treat non-graduation candidates as noise. If you are using the built-in user-agent runtime, encode this in your system_prompt and let the LLM apply the bias each cycle.

Deployment Options

For a production agent, you need continuous execution:

Cron on a VPS — cheap, simple, reliable. $5/month on any provider.
AWS Lambda + EventBridge — serverless, scales to zero, pay per cycle.
Cloudflare Workers + cron triggers — free tier covers most hobby agents.
Your own laptop — works, but only while the laptop is on.

For webhook-driven agents, you need a public HTTPS endpoint. Cloudflare Workers or a small VPS with Caddy both work. Avoid ngrok in production — use a real domain.

Extending the Agent

Once the baseline is live, good directions to extend:

Dynamic position sizing — scale buy size with conviction (the built-in user-agent uses a 20% / 50% / 100% tier for low / med / high).
Multi-token correlation — detect when multiple tokens pump together (regime shift).
Creator reputation weighting — penalize deployers who dump on holders.
Trailing stops — raise the stop loss as position moves into profit.
Time-of-day modulation — bots dominate certain hours; humans others.

Every addition should be tested with tiny caps first (0.0001 ETH max position). Strategies that look great in backtest often die in live conditions because of slippage, rate limits, and event ordering that the backtest did not model.