GPT-6 Astra vs Fable 5.1: What 100 Hours of Real Agent Work Show

Yesterday I watched a test that answers the question our Astra rollout post left open: what does GPT-6 Astra do in real agent work, not in benchmarks? Nate Herk ran both models through 15 real use cases. Web design, organization, taxes, browser automation, vision, building software. 100 hours of testing, every task measured for time and cost. It is the most honest comparison available right now.

Astra won 10 of the 15 tasks, Fable won five. The totals: Fable needed 9 hours 35 minutes of runtime and cost 513.36 dollars. Astra needed 11 hours 19 minutes and cost 326.98 dollars. Translated: across the whole test Astra was 186 dollars cheaper but one hour and 43 minutes slower. Both models self-reported the stats and the tester verified they matched.

The pattern matters more than the sum. Astra won the tasks that require judgment: browser automation with unclear target structure, image analysis, building software from vague specifications. Fable won where precise, well-structured work counts, and was faster and cheaper per task in several cases, but lost expensive outliers where it wandered off. One example from the test: a task where Fable burned 42 minutes and roughly 27 dollars, Astra solved in 17 minutes for a fraction of that.

The API prices explain it. GPT-6 Astra costs 10 dollars per million input tokens and 50 dollars per million output tokens on the standard tier, about two and a half times GPT-5.6 Sol at 4/20. If Astra still comes out cheaper in real work despite the higher token price, it repeats failed attempts less: fewer retries, fewer dead ends for the same task. That is exactly what the system card hinted at, and here it shows up in dollars.

The lesson is not "Astra is better". It has three parts. First, benchmarks tell you nothing about agent work: OSWorld and ARC-AGI-3 measure single moves, the 15-task run measures the series. Second, runtime is a currency: Astra was slower but cheaper; if you budget cloud money, pay in time, if you have deadlines, pay in tokens. Third, plan limits count: Astra has no five-hour Codex window and no Fable weekly cap, it runs all week, which is exactly what makes it interesting for continuous operation like ours, not for single tasks.

My agent stack runs on a 45-euro phone with cloud models, and my daily work lives on small scripted steps with rare model calls. For most of those steps GPT-5.6 Sol is still overqualified and much cheaper. The tester says it himself at the end: both models have strengths, and the landscape shifts faster than subscriptions. My plan stays: Astra for heavy analysis, Sol for the daily grind, and the measurement chain decides on every run. That is the operation we document.

It is one user with his 15 tasks, not a controlled study. The costs come from the two models' self-reporting, cross-checked by the tester, but it is not an external measurement. And the 15 use cases are his selection, not a standard. What the test still delivers: the best public approximation so far of the question that has followed us since the Astra rollout, what the model costs and delivers in real work.

The setup deserves its own look, because there is more care here than in the usual quick comparisons. For each of the 15 use cases, both models ran the same task with the same starting conditions and the same tool chain. Three quantities were measured: output quality against the task's criteria, runtime in minutes, and cost in dollars. The costs come from the models' own reporting, cross-checked against each other; there was no external billing from a third party. That is the most important methodological limit, and it should be known before quoting the numbers.

Also notable: the two models reported their output differently. One gave detailed step-by-step token accounting, the other summarized more. Anyone rebuilding this kind of test should therefore keep the raw logs and not only compare the final sums, otherwise you measure the reporting style of the models instead of the work itself. That is not a criticism of the test, it is a note for anyone reproducing the format.

Across the 15 tasks a pattern emerges that matters more than the final score. Astra won the majority of tasks that required judgment: operating unfamiliar websites, building software from incomplete specifications, evaluating images. Fable won where the task had a clear, narrow specification and precision counted on the last mile. The outliers are interesting in both directions: there were tasks where one model looped, self-corrected and inflated cost and time while the other solved it in one pass. Those outliers, not the average, shaped the totals.

For operators the practical rule is that this is not an either/or decision, it is a routing question. Tasks with uncertain specifications run economically on the model that shows judgment in unclear territory. Narrow, well-defined tasks run on the more precise model that is faster per task. Sending everything through one model means paying either the outliers or the precision unnecessarily.

The five tasks Fable won are not a random sample. In all five cases the value of the task was exact obedience to a clear specification: filling defined data structures, keeping given formats, small changes with exact boundary conditions. Astra solved those tasks as well, but more expensive or slower, because by its own pattern it invested more verification into the output than the task required. That matches the consumption observation from the video: Astra triple-verifies where once is enough.

The uncomfortable truth for anyone swearing by one model: the better model for a task depends on the specification, not the brand. A team mostly implementing clear requirements does better with the per-task faster model. A team working with vague requirements pays the outliers on that model. The tester says so himself at the end, and it is the only conclusion the numbers really support.

Anyone adopting this test format needs three things beyond traceability. First, a fixed task list with acceptance criteria defined before the run, otherwise you score afterwards in favor of your favorite. Second, cost and time tracking that does not come from the models themselves but from the API billing. Third, multiple repetitions per task, because a single run produces outliers, which here happened to shape the overall picture. The video test is the best public starting point, but it is the beginning of a methodology, not its end.

10 of 15 tasks, and 186 dollars cheaper in total. At the same time Astra was about 1 hour 43 minutes slower across all tasks. If you budget time instead of money, the verdict changes.

10 dollars per million input tokens and 50 dollars per million output tokens on the standard tier, about 2.5 times GPT-5.6 Sol.

For multi-step agent tasks with vague specifications, browser work and image analysis. For short, clear tasks Sol is cheaper and usually enough.

Yes: in precise, structured tasks, and per task it was faster and cheaper in several cases before expensive outliers flipped the totals.

Test video: Nate Herk, "100 Hours Testing GPT-6 Astra vs Fable 5.1" (youtube.com/watch?v=WfJPBVXPt8k), retrieved September 6, 2026

OpenAI API pricing (developers.openai.com/api/docs/pricing), retrieved September 6, 2026

GPT-6 Astra pricing overview (cloudzero.com/blog/gpt-6-pricing), retrieved September 6, 2026

Own assessment from HUNTER operation, as of September 6, 2026