We Gave Claude Opus 5.5 and GPT-6 Sol $100 Each to Trade Polymarket Bitcoin. Here's Who Won

Claude Opus 5.5 and GPT-6 Sol launched the same week, and on public benchmark leaderboards Claude is ahead. No benchmark measures what a trader does every five minutes, though: read a live market, make a call, and back it with money. So we gave each model the same $100 starting balance, the same data and the same rules, and let them trade Polymarket's "Bitcoin Up or Down" markets head to head for two hours.

How did the test work?

The session ran on Sunday, 27 September 2026, from 1:55 to 3:55 AM ET: 24 back-to-back Polymarket markets, each lasting five minutes. The goal was the highest balance at the end.

At 1:55 into each window, a referee script froze one snapshot of the market and sent both models exactly the same text. Calls were due by 4:10 and stayed sealed until both were in. Orders were then priced at the snapshot's order book, so thinking faster or slower gained nothing. Anything that did not fill at once rested at the model's limit until 4:45, and each market settled on Polymarket's official result.

These markets resolve Up if Chainlink's time-weighted average BTC/USD price for the window is at or above the price at the start of the window, and Down otherwise. The averaging matters: by 1:55, almost 40% of the averaging period is already locked in, which is why both models often paid 90 cents or more for the side that was ahead.

All the live data came from Predictefy over a single WebSocket connection: Polymarket's Up and Down order books and trades, the Binance BTC/USDT price and Chainlink's BTC/USD price. One REST call per window looked up each new market, and every order was priced against Polymarket's live order book.

What was different between the two: Claude ran as one long Claude Code session, woken every minute by its own scheduled job, and could run only two commands, one to fetch the snapshot and one to submit its call. GPT-6 Sol ran a fresh codex exec for each game, read-only and with no tools, answering in JSON against a fixed schema. Because Claude stayed in one conversation, it could see its own earlier reasoning, while GPT-6 Sol started fresh each game. Both saw their balance and their last five calls in every snapshot.

What did the models see?

Text only, no charts. Each snapshot showed the Binance price against the window's start, recent momentum and volatility, the Chainlink price that settles the market, the top of Polymarket's order book with the taker fee per share, the trade flow so far, the last eight results and the player's own account. It also included a probability of Up from the arena's own simple model, built from the distance to the start price, the time left and volatility. This was the snapshot for game 1:

ARENA SNAPSHOT | game 1 of 24 | Bitcoin Up or Down, September 27, 1:55AM-2:00AM ET
Frozen at 1:55 into the window. Orders are priced at this snapshot's order book. Send your call by 4:10 (13:59:10); anything unfilled rests until 4:45.

BTC (Binance) 84,480.8 | window start reference 84,487.6
  vs start: now -6.8 | last-60s average -6.8 | whole-window average -7.0
  momentum: last 60s -0.0 | last 180s -13.5
  volatility: about $20.4 per sqrt-minute
Chainlink BTC/USD (on-chain, updates every ~10-60s): +1.7 vs its start value
Model probability of Up: 0.439 (Binance-based 0.355, Chainlink-based 0.522)
Order book: Up bid 0.28 / ask 0.29 (size 806) | Down bid 0.71 / ask 0.72 (size 67) | market-implied chance of Up 0.285
Taker fee per share at the ask: Up 0.0144, Down 0.0141
Trade flow this window (351 trades): Up bought $931 sold $24 | Down bought $1,747 sold $117
Recent results, oldest to newest: D U D D U U D D

YOUR ACCOUNT: balance $100.00 | P&L +0.00 | 0W 0L 0 skips

Both models bought Up here. The market priced it at 29 cents while the model said 44%, and Bitcoin's average finished above the start: Claude made $22.43 and GPT-6 Sol $35.98.

Before the first game, each model stated its plan in three lines. GPT-6 Sol said it would "trade only when that estimate beats the available ask after fees; otherwise I'll skip." Claude said it would "skip coin-flip markets and books priced near fair" and "protect the 100 USD bankroll." Both kept those promises, and the difference between them decided the match.

Who won, Claude Opus 5.5 or GPT-6 Sol?

The lead changed hands three times in the first hour. Claude peaked at $133.78 after game 8, and GPT-6 Sol never fell below its starting $100. Then game 13 put GPT-6 Sol in front for good.

Three simple strategies ran on the same markets as benchmarks, at $5 a game including fees:

Why did Claude lose money with a 71% win rate?

Because the price you pay decides what a win is worth. A share bought at 92 cents earns 8 cents if it wins, minus the fee, and loses 92 cents if it doesn't. Claude made 12 of its 14 trades on the favorite, paying from about 58 to 94 cents a share. It won 9 of them, and those 9 wins earned $19.69. Its 3 losing favorites, in games 10, 17 and 20, cost $39.33, twice as much.

Game 17 shows how that happens. Bitcoin was 24 dollars above the start with about three minutes left, and Claude paid 89 cents for Up, reasoning that "the averaged settlement strongly favors Up." The average slipped below the start anyway, and that one loss of $14.94 erased more than all six small favorite wins before it. The always-buy-the-favorite benchmark tells the same story: it won 16 of 24 and still lost $19.61.

GPT-6 Sol lost money on favorites too, $21.78 across 8 trades. Its profit came from 11 long shots bought under 50 cents. It won only 5 of them, but those 5 earned $167.06 against $76.74 lost on the other 6, a net gain of $90.32. Claude bought just two long shots, and made $17.43 on them.

Where did GPT-6 Sol's lead come from?

From the games Claude sat out. The two models took the same side in 10 games and opposite sides in just one, game 8, which Claude got right. In those 10 shared games, Claude actually did better, making $9.13 while GPT-6 Sol lost $11.29 on bigger stakes. The gap came from the 8 games where only GPT-6 Sol traded: it made $84.94 there, mostly by buying the cheap side whenever the arena's model rated it underpriced after fees.

Game 13 decided the match. Bitcoin was about 10 dollars below the start, the market priced Up at 16 cents, and the arena's model gave Up a 27.5% chance. GPT-6 Sol bought $14 of Up, noting that the "model Up probability 27.5% exceeds the 16% ask plus 0.94% fee." Claude looked at the same snapshot, judged Down "about fair" and skipped. Bitcoin's average finished above the start, and GPT-6 Sol's 87.5 shares returned $72.68 in profit. Without that one trade, GPT-6 Sol would have ended $4.14 down.

Did the AI add anything beyond the arena's own model?

Less than you might expect. Most of GPT-6 Sol's reasons quote the arena's probability against the ask, and its record looks like the model-only benchmark's: 19 trades and 11 wins, against 18 trades and 10 wins. The model on its own, betting a flat $5 a game, made $64.46 while risking about $90. GPT-6 Sol made $68.54 but risked $308.63 to do it. Claude read the same number but overrode it more often, demanding a bigger edge and trusting its own read of the averaged settlement, which kept it near break-even.

The lesson for builders: the language model mattered less than the numbers it was given. Both AIs were reading a price model built on live Binance and Chainlink data set against the order book, and the plain model did nearly as well as the better of them, with less than a third of the money at risk.

What can a two-hour test tell you?

Not much about which model is the better trader. Twenty-four games is a tiny sample: a coin flip made $33.13 in the same session, and one trade accounts for GPT-6 Sol's whole profit. Every order was priced at the snapshot, which works at these small stakes but would not hold for large orders in a thin book. It was one session, overnight in the US, with one prompt design, and Claude kept its memory between games while GPT-6 Sol did not.

What the test does show is how differently the two models behave with identical information. Claude is picky and leans toward the likely side, skipping anything it judges fairly priced. GPT-6 Sol takes any edge it sees after fees, including long shots, and bets the $25 maximum far more often: seven times, against Claude's once. Over two hours that style won, but a longer run is the only way to know whether it holds.

How to run your own AI trading arena

The setup is simple to copy. Stream the market and the reference prices, freeze one snapshot per window, send the identical text to each model at the same moment, price the orders at the snapshot with the taker fee, and settle on Polymarket's official result. The data part takes a few lines with the Predictefy API: one REST call finds the current window's market, and one WebSocket streams its order books next to the Binance and Chainlink prices.

import asyncio, json, os, time
import requests, websockets

AUTH = {"Authorization": f"Bearer {os.environ['PREDICTEFY_API_KEY']}"}

def current_window():
    start = int(time.time()) // 300 * 300
    event = requests.get("https://data.predictefy.com/api/polymarket/fetchEvent",
                         params={"slug": f"btc-updown-5m-{start}"}, headers=AUTH, timeout=10).json()["data"]
    return {o["label"].lower(): o["outcomeId"] for o in event["markets"][0]["outcomes"]}

async def main():
    ids = current_window()
    async with websockets.connect("wss://stream.predictefy.com/v1/stream", additional_headers=AUTH) as ws:
        await ws.send(json.dumps({"op": "subscribeFeedTicker", "feed": "binance", "symbol": "BTC/USDT"}))
        await ws.send(json.dumps({"op": "subscribeFeedTicker", "feed": "chainlink", "symbol": "BTC/USD"}))
        for side in ("up", "down"):
            await ws.send(json.dumps({"op": "subscribe", "channel": "orderbook",
                                      "venue": "polymarket", "marketId": ids[side]}))
        async for raw in ws:
            msg = json.loads(raw)
            if msg.get("type") == "feedTicker":
                print(msg["feed"], msg["data"]["last"])
            elif msg.get("type") in ("snapshot", "update"):
                asks = [float(a["price"]) for a in msg["data"].get("asks") or []]
                side = "Up" if msg["marketId"] == ids["up"] else "Down"
                print(side, "best ask", min(asks) if asks else None)

asyncio.run(main())

For more on the markets themselves, see how to track 5 minute Bitcoin markets, and for turning a model into a working bot, how to build a prediction market trading bot with Claude.

Frequently Asked Questions