Portal clone, seven models

Each subdirectory is the same task given to a different model: build a web Portal clone with a portal gun and a test room, using Vite and TypeScript, built with bun into a single HTML file. The base prompt is in prompt.

Directory	Model	Harness	Effort
opus-5.5/	claude-opus-5-5 (1M context)	Claude Code	high
opus-5/	claude-opus-5 (1M context)	Claude Code	high
sonnet-5.5/	claude-sonnet-5-5 (1M context)	Claude Code	high
haiku-5.5/	claude-haiku-5-5 (1M context)	T3 Code (Claude provider)	high
sol-6/	gpt-6-sol	Codex	high
sol-6.1/	gpt-6.1-sol	Codex	high
astra-6/	gpt-6-astra	Codex	high

Summary

	opus-5.5	opus-5	sonnet-5.5	haiku-5.5	sol-6	sol-6.1	astra-6
API cost (list price)	$6.99	$11.25	$3.10	$0.79	$1.86	$1.08	$5.57
Active agent time	25m 26s	47m 22s	21m 08s	14m 28s	18m 38s	38m 55s	20m 48s
Model requests	68	77	49	45	89	40	41
Tool calls	73	88	61	63	88	38	40
Total tokens processed	10.95M	11.40M	7.74M	7.98M	6.34M	2.84M	2.68M
Output tokens	148,465	145,408	154,032	160,436	42,342	45,810	36,265
of which thinking	82,402	78,829	97,110	125,952	11,188	9,245	5,567
Largest context	236,676	222,898	217,062	242,923	98,132	99,878	86,122
Source (.ts, .tsx, .css)	2,643 lines / 98 KB	2,259 lines / 71 KB	2,432 lines / 83 KB	1,068 lines / 32 KB	106 lines / 30 KB	584 lines / 58 KB	689 lines / 58 KB
dist/index.html	543 KB (141 KB gz)	533 KB (138 KB gz)	586 KB (149 KB gz)	550 KB (139 KB gz)	727 KB (267 KB gz)	820 KB (220 KB gz)	540 KB (140 KB gz)

haiku-5.5 was the cheapest and fastest run: $0.79 in 14m 28s. It processed about as many tokens as sonnet-5.5 (7.98M) and wrote the most output of any run, 160K tokens, 126K of them thinking. Haiku 5.5 is the only model here whose price depends on prompt length. Up to 100K tokens it costs $0.10/$0.50, a twentieth of Sonnet 5.5. Above 100K, counting cached tokens, it costs five times that. 41 of its 45 requests were over the line, so it paid $0.79 instead of the $0.20 it would have cost at the lower rate. It wrote the least code of the Claude runs, 1,068 lines.

sol-6 cost about a quarter of opus-5.5 and a sixth of opus-5. It also wrote far less code. Its main.ts is 99 lines, but the lines are very long (22 KB), so the line count undersells it. Its build is bigger because it bundles six .woff2 font files.

The two Opus runs used almost the same tokens, but opus-5.5 cost $4.26 less. Most of the gap is cache reads: Opus 5.5 charges $0.20 per million against Opus 5's $0.50, which saved $3.41. The rest comes from its lower input and output prices ($4/$20 vs $5/$25). It also finished in about half the time.

sonnet-5.5 cost $3.10, about 44% of opus-5.5 and 1.7 times sol-6. It made fewer requests than either Opus run (49) and wrote 154K output tokens, 97K of them thinking. Every Sonnet 5.5 rate is half the Opus 5.5 rate ($2/$10, cache reads $0.10), and the run read 30% fewer cached tokens.

astra-6 processed the fewest tokens of any run (2.68M) and wrote the least output, but GPT-6 Astra costs five times as much per token as Sol ($10/$50), so it came to $5.57, three times sol-6. Its code is dense like sol-6's: style.css is 10 KB on 4 lines.

sol-6.1 was the cheapest GPT run at $1.08, a little over half of sol-6. GPT-6.1 Sol halves the cached-input price to $0.10, and the run read 58% fewer cached tokens than sol-6 (2.61M vs 6.20M). It took twice as long, 38m 55s. It is the only run that used React and Tailwind, and its build is the largest at 820 KB.

Token breakdown

Input tokens are split the way each API bills them.

	opus-5.5	opus-5	sonnet-5.5	haiku-5.5	sol-6	sol-6.1	astra-6
Uncached input	136	227	98	90	99,854	182,241	123,718
Cache writes (1h TTL)	238,743	209,441	205,494	226,759	n/a	n/a	n/a
Cache reads	10,561,194	11,047,292	7,381,682	7,589,432	6,195,328	2,612,480	2,522,496
Output (incl. thinking)	148,465	145,408	154,032	160,436	42,342	45,810	36,265

Cost breakdown

	opus-5.5	opus-5	sonnet-5.5	haiku-5.5	sol-6	sol-6.1	astra-6
Uncached input	$0.00	$0.00	$0.00	$0.00	$0.20	$0.36	$1.24
Cache writes	$1.91	$2.09	$0.82	$0.22	n/a	n/a	n/a
Cache reads	$2.11	$5.52	$0.74	$0.38	$1.24	$0.26	$2.52
Output	$2.97	$3.64	$1.54	$0.19	$0.42	$0.46	$1.81
Total	$6.99	$11.25	$3.10	$0.79	$1.86	$1.08	$5.57

Rates used, per million tokens:

Model	Input	Output	Cache read	Cache write (1h)
claude-opus-5-5	$4.00	$20.00	$0.20 (0.05x input)	$8.00 (2x input)
claude-opus-5	$5.00	$25.00	$0.50	$10.00
claude-sonnet-5-5	$2.00	$10.00	$0.10 (0.05x input)	$4.00 (2x input)
claude-haiku-5-5, prompt ≤ 100K	$0.10	$0.50	$0.01	$0.20 (2x input)
claude-haiku-5-5, prompt > 100K	$0.50	$2.50	$0.05	$1.00 (2x input)
gpt-6-sol	$2.00	$10.00	$0.20	$2.50, none reported
gpt-6.1-sol	$2.00	$10.00	$0.10	$2.50, none reported
gpt-6-astra	$10.00	$50.00	$1.00	$12.50, none reported

The biggest line is cache reads for opus-5, haiku-5.5, sol-6 and astra-6, and output for opus-5.5, sonnet-5.5 and sol-6.1. Opus 5.5 and Sonnet 5.5 bill cache reads at a twentieth of the input price instead of a tenth, which pushes output to the top. An agent re-sends the whole conversation on each request, so a 200K-token context read 40 to 80 times adds up even at those discounts.

How each run went

The runs did not get identical prompts, which affects the comparison.

opus-5.5. Got the original prompt (Vite + TypeScript, "ask questions if you want"). The first turn took 23m 45s. The user then asked for bun and a single-file build (45s), asked it to kill the dev server (11s), and asked whether VR support would be easy (28s). That session ran at the repo root, and the files were moved into opus-5.5/ afterwards. A second, short session added the .gitignore (medium effort, $0.14). Both sessions are included in the totals.

opus-5. Got the combined prompt from prompt, with bun and single-file in it from the start. It asked three design questions first, all answered "your choice" (33s of wait time, excluded from active time). The user interrupted it after 33m 53s and told it to "keep going", and it finished 14 minutes later. Its README is the longest of the seven (115 lines) and explains how the portal rendering works.

sonnet-5.5. Got the combined prompt from prompt. The user interrupted the first attempt after 36s and sent the same prompt again. The interrupted attempt wrote no usage to the transcript, so it is not in the totals. The second turn ran 21m 08s with no further input and no questions. It play-tested its build in a browser preview: 31 of its 61 tool calls were preview calls (21 script evaluations, 9 screenshots, 1 open).

haiku-5.5. Got the combined prompt from prompt, launched as a T3 Code thread on the Claude provider. The first attempt ran in haiku-5.5/ inside this repo, and in its first minute it read this README, the prompt file and opus-5.5/package.json. The user stopped it there and the attempt was discarded; it is not in the totals. The second attempt ran in an empty directory outside any git repository (/tmp/haiku-5.5-run/portal), and the files were copied into haiku-5.5/ afterwards. It ran 14m 28s with no further input and no questions. 30 of its 63 tool calls were T3 Code browser preview calls (12 snapshots, 10 navigations, 5 script evaluations, 1 open, 1 click). Pointer lock does not engage in the headless preview, so it checked placement, teleport and collision by running its modules under Bun, and checked the portal views with a temporary debug hook that it removed afterwards. That testing turned up a real bug: a negative timestep on the first frame sank the player into the floor and pushed them out of the room. It fixed it. It left no tests in the project.

sol-6. Got the original prompt. The bun and single-file request came in as a mid-turn message at the 12-minute mark, and it handled both in the same turn. Every tool call was a shell exec. The run used 1% of the Codex weekly limit (18% to 19%).

astra-6. Got the combined prompt from prompt and ran with no further input. All 40 tool calls were shell execs. It wrote six unit tests for the portal math (tests/) and play-tested the build with the Playwright CLI, leaving 5 MB of screenshots in the gitignored output/ and .playwright-cli/. It also left the Playwright browser running when it finished. The run used 1% of the Codex weekly limit (2% to 3%).

sol-6.1. Got the combined prompt from prompt and ran with no further input. It spawned one subagent, which made a social preview image (public/og.png) with a single image-generation request. The subagent's tokens are in the totals; the image request is not priced. It wrote 12 tests and added oxlint. The Codex weekly limit stayed at 3%.

Red flag: nobody asked it to deploy anything, but it published the build to ChatGPT Sites as a private hosted preview. To do that it ran git init inside sol-6.1/, committed the project, pushed it to a sites remote on OpenAI's servers, and deployed it through the Codex Sites connector. None of the other runs published anything off the machine. The user had it take the preview down in a follow-up turn, which is not counted in these numbers.

Where the numbers come from

• Claude runs: Claude Code transcripts in ~/.claude/projects/-home-paucapo-Codi-Portal*/, and for haiku-5.5 in ~/.claude/projects/-tmp-haiku-5-5-run-portal/ (T3 Code's Claude provider writes the same transcripts). Usage comes from each assistant message's usage field, deduplicated by message and request ID because Claude Code writes one line per content block. Thinking tokens come from output_tokens_details.thinking_tokens.
• GPT runs: Codex rollouts in ~/.codex/sessions/2026/09/{24,29,30}/, final token_count event. sol-6.1 has two rollouts, the main session and its subagent, and both are counted up to the end of the first turn. Codex reported no cache writes for any GPT run.
• Active time: turn start and end timestamps, excluding time spent waiting on the user.
• Prices: Anthropic list prices from Anthropic's pricing page; GPT-6 Sol, GPT-6.1 Sol and GPT-6 Astra at the short-context rates on OpenAI's pricing page. Haiku 5.5 is priced per request: a request whose prompt (uncached input plus cache reads plus cache writes) is over 100K tokens pays the higher rates for all of its tokens, output included. The other Claude models have no long-context tier, and no GPT run reached OpenAI's 272K threshold.

These are what the tokens would cost on the pay-as-you-go API. All seven runs used subscriptions (Claude Max and Codex), so nobody was billed these amounts.