Do We Need Deep Thinking? Why Fable 5.1 and Astra Look Smart and Gemini 3.8 Flash Looks Dumb

TL;DR

• You are comparing two flagships to one workhorse. Fable 5.1 and GPT-6 Astra (September 2026, $10 in /$50 out per million tokens) against Gemini 3.8 Flash (September 2026, $0.75 /$3.75 intro). Different price, different job.
• Google’s flagship is old. On September 18, 2026 the listed Pro model is still the February 2026 Gemini 3.1 Pro Preview. Flash is fresh. Pro is seven months stale.
• More thinking often hurts. ACL Findings 2026 found a clear pattern: easy tasks go wrong after ~2K thinking tokens, hard tasks after ~8K. Past ~7K tokens, models flip more right answers to wrong than the reverse.
• Try it yourself below. One bug-fix prompt, three answers: a fast fix, a slow fix that costs 10x for the same result, and a long chain that talks itself out of the right answer.
• New option: skip thinking entirely. Jev from TypeSafe AI (early access, September 15, 2026) answers typed decisions — choice, score, yes/no probability — in ~100 ms at $0.042 per million input tokens. No chat. No essays. Just a number your code can use.
• My take: do not buy tokens. Run a small effort sweep on your own tasks. Find which task types need max and which are fine at low. Route the rest to cheap checks — or to Jev.

What You Will Learn Here

• Why the Fable/Astra vs Flash comparison misleads, in plain terms
• What one prompt looks like at low vs max effort, with tokens and cost
• What a reasoning trace looks like — and what an overthinking flip looks like
• What Fable 5.1 and Astra actually sell you (a thinking budget, not magic)
• What Jev is, when it beats a chat model, and how to call it
• How to run a small effort sweep so you stop guessing

Two Flagships and One Workhorse

Ask three models the same hard question. Fable 5.1 thinks carefully. Astra thinks for a long time. Flash answers fast and thin.

That story is real. The lesson people draw from it is wrong.

On September 18, 2026, these are not three equal models:

Sources: Fable 5.1 overview, effort docs, OpenAI Astra launch, Gemini 3.8 Flash blog, Gemini model page (accessed Sept 18, 2026), Gemini 3.1 Pro page.

Two facts matter more than any benchmark table.

First, the price gap is huge. Fable and Astra cost about 13x Flash intro pricing. A $10/$50 model out-thinking a $0.75/$3.75 model on the same prompt is the plan working. It does not prove Flash is dumb.

Second, Google’s flagship is stale. The Gemini page on September 18, 2026 still lists 3.1 Pro and 3.1 Deep Think from February, plus “3.5 Pro coming soon.” Google’s own September 2 blog says Flash is the fast-moving line: three Flash releases in six weeks.

Vendor tables reflect this. Flash matches or beats flagships on narrow, well-set-up tasks — coding, finance, legal — and falls behind on open-ended agency work. One example: Terminal-Bench 4.0 (general agency) shows Astra 57.9% and Fable 5.1 55.8% vs Flash 19.1% in vendor-reported September tables. On narrow DeepSWE v1.1, Flash sits at 73.7–73.8%, right next to Astra at 74.1%.

Treat every vendor cell as vendor-reported, not independently checked. Test harnesses differ by vendor, so exact numbers are not comparable. The pattern is stable though: cheap and fast wins on narrow tasks, expensive and slow wins on open agency.

Editorial judgment: the “dumb” feeling comes from three stacked mismatches — price tier (workhorse vs flagship), age (September vs February), and task type (narrow vs open). Fix the comparison before you blame the model.

See the Difference: One Prompt, Three Answers

Enough theory. Here is the same bug-fix prompt run three ways. This is the pattern you will see in your own logs.

The prompt (a routine retry bug):

Fix this Python retry helper. It should retry 3 times with
exponential backoff (1s, 2s, 4s), only retry on TimeoutError,
and stop retrying on ValueError.

def call_api(fn):
    for i in range(5):
        try:
            return fn()
        except Exception:
            continue
    return None

Answer 1 — low effort: fast and right.

def call_api(fn):
    import time
    delays = [1, 2, 4]
    for attempt, delay in enumerate(delays + [None]):
        try:
            return fn()
        except ValueError:
            raise
        except TimeoutError:
            if attempt == 3:
                raise
            time.sleep(delay)

Tokens: ~200 thinking + ~150 output. Cost on a $10/$50 flagship: about $0.01. Time: ~12 seconds in one secondary probe. Correct.

Answer 2 — max effort: slow and also right.

The model re-derives backoff math, debates tenacity vs hand-rolled loops, checks edge cases twice, and lands on the same fix.

Tokens: ~5,700 reasoning + output. Cost: about $0.30. Time: ~105 seconds. Same correct answer. Roughly 10x the cost and 8x the wait — for nothing extra.

This matches two small secondary probes on Astra (ComputingForGeeks and SynthorAI, September 2026): low to max went from ~213 to ~5,684 reasoning tokens with the same correct answer.

Answer 3 — too much thinking: slow and wrong.

On easy tasks, long chains often flip a right answer to a wrong one. The trace looks like this (shortened summary, not a raw chain-of-thought):

Step 1: Correct fix drafted (retry only TimeoutError, 1s/2s/4s).
Step 2: "Wait — should ValueError also retry? What if the API wraps
  timeouts as ValueError? Let me handle both..."
Step 3: Rewrites to retry on all exceptions. Breaks the spec.
Final: returns the buggy version with extra comments.

That is the ACL Findings 2026 result in miniature: past a point, extra thinking adds more wrong-to-right flips in reverse. Easy tasks tip near ~2K tokens. Hard tasks tip near ~8K. Beyond ~7K, bad flips outnumber good ones.

How to prompt for each level:

# For routine work — ask for short reasoning explicitly:
"Fix the retry helper. Reply with corrected code + 3 bullet
notes max. Do not explore alternatives."

# For hard work — ask for checks, not length:
"Fix the retry helper. Before answering, list 2 failure modes
of your fix and how you ruled each out. Keep it under 200 words
plus code."

Short prompts like the first one keep low honest. The second prompt helps at high without inviting a 6K-token ramble. Length is not quality. Checks are quality.

When More Tokens Hurt

The folk theory says: more thinking, smarter answer. 2026 research measured it and found a hump shape. A little thinking helps. Too much hurts.

ACL Findings 2026 — “When More Thinking Hurts” (paper):

• Easy problems start going wrong near 2K thinking tokens. Hard ones near 8K.
• Past ~7K tokens, correct-to-wrong flips beat wrong-to-correct flips.
• Stopping early keeps ~97% of peak accuracy at ~60% of the compute.

ICLR 2026 — OptimalThinkingBench (paper) tested 33 models both ways: simple questions (do models overthink?) and hard tasks (do they underthink?). Result: thinking models overthink easy questions for no gain. Non-thinking models underthink hard ones. No model gets both right. Top score was o3 at 71.1%.

Older work saw the same hump: When More is Less (arXiv 2502.07266) and Towards Thinking-Optimal Scaling (arXiv 2502.18080). Stronger models need shorter chains — a “simplicity bias” you can see in the Fable Low results (Fable Low vs Opus Low vs Sonnet Low).

What this means for you:

1. Never ask “how much thinking?” Ask “how much thinking for this task?”
2. A uniform max-everywhere policy is a cost bug and a quality bug.
3. The length-budget piece made the human version of this point. The ACL paper makes the model version.

What Fable and Astra Actually Sell You

Strip away the launch charts. Both flagships sell the same thing: a thinking budget with five notches, adjustable per message.

Fable 5.1 (docs, September 1, 2026):

• Thinking is always on. You pick effort from low to max. Default is high.
• Low effort can skip thinking on simple tasks. High effort thinks on most requests, longer.
• New in 5.1: change effort mid-conversation without losing your prompt cache (beta), plus step-by-step progress notes between tool calls (beta).
• Practical rule from Anthropic: start at high. Move up for hard agentic work. Move down for routine work once your tests say quality holds.

Astra (OpenAI launch, September 3, 2026):

• Same five levels: low, medium, high, xhigh, max. You set reasoning.effort in the Responses API.
• You can change effort mid-conversation and keep your cache.
• Vendor-reported peaks: FrontierMath Tier 4 v2 ~97.6%, ARC-AGI-3 99.9% with a special harness, Terminal-Bench 4.0 57.9%. Treat these as ceiling numbers at max effort, not everyday numbers.

Flash runs the same pattern on a smaller budget. Google’s September 2 blog says it directly: “3.8 Flash works harder. On complex tasks, it exhibits greater diligence — executing extra reasoning steps, and calling tools iteratively.” For cheap, fast work, Google tells you to use lower effort or stay on 3.7 Flash.

Editorial judgment: the real gap is not a secret model layer. It is training that teaches when to think, plus an API that lets you steer it. Teams that set everything to max get higher bills and more overthinking flips.

What If You Skip Thinking Entirely? Meet Jev

Here is the newest twist, from September 15, 2026. TypeSafe AI came out of stealth with $40M in seed funding and a model called Jev (jev-1.13.0, alias jev-latest). It is not a chat model. It makes fast, typed decisions for code.

You send it facts. It sends back a decision with a probability. No essay. No chain-of-thought. Most calls finish in ~100 ms (vendor range: 70–500 ms end to end).

Three answer types:

• Noul — a yes/no probability. “Is this ticket a billing issue? 0.92.”
• Choice — pick one option you defined. “Route to: billing / technical / fraud.”
• Score — a number on your scale. “Urgency: 0.8.”

Sources: TypeSafe launch post (Sept 14, 2026), Flavio Copes deep dive (Sept 17, 2026), OmniaKey explainer (fact-checked Sept 19, 2026), OpenRouter pricing (Sept 18, 2026). Speed and price claims are vendor-reported. Treat TypeSafe’s “193.6x faster, 444.6x cheaper” headline as a best case from its own workflow tests, not what you will measure.

A Jev call looks like this:

import requests

resp = requests.post(
    "https://api.typesafe.ai/v1/systemone",
    headers={"Authorization": f"Bearer {API_KEY}"},
    json={
        "model": "jev-latest",  # resolves to jev-1.13.0
        "state": "My card was charged twice for the same order.",
        "questions": {
            "route": {
                "type": "choice",
                "instructions": "Which team handles this?",
                "criteria": {
                    "billing": "Duplicate charges, refunds",
                    "technical": "Bugs, crashes",
                    "fraud": "Stolen card, account takeover",
                },
            },
            "is_billing": {
                "type": "noul",
                "instructions": "Is this a billing issue?",
            },
            "urgency": {
                "type": "score",
                "instructions": "How urgent is this from 0 to 1?",
            },
        },
    },
    timeout=10,
)
data = resp.json()
print(data["answers"]["route"])      # {"value": "billing", "probabilities": {...}}
print(data["answers"]["is_billing"]) # {"value": True, "probability": 0.92}
print(data["answers"]["urgency"])    # {"value": 0.8, ...}

Pin jev-1.13.0 (not jev-latest) if you tune thresholds. Log the versioned ID the response reports.

When does Jev beat deep thinking?

flowchart TD
    Q[New task arrives] --> T{Is the answer\nprose or a decision?}
    T -- Prose, code, plan --> L[LLM at tuned effort\nlow for routine, high for hard]
    T -- Choice, score, yes/no --> J[Jev decision\n~100ms, $0.042/M in]
    J --> C{Confidence high?}
    C -- Yes --> ACT[Act in code]
    C -- No --> L
    L --> G[Log result\nre-tune monthly]

Jev cannot write, explain, code, or do math for you. It pairs with a thinking model: Jev routes and checks, the LLM does the open work. For agent loops that call “should I escalate?” hundreds of times a day, that split is the whole cost story.

Architecture in 30 Seconds

You do not train these models. You just need the shape of the trend.

flowchart LR
    A[Dense Transformer<br/>full memory per token] --> B[Cheaper attention<br/>shared memory per token]
    B --> C[Mixture-of-Experts<br/>big library, few books open]
    C --> D[Smaller history<br/>compress or skip old tokens]
    D --> H[2026 frontier:<br/>smart thinking budgets\n+ Jev-style no-thinking checks]

Three steps got us here: cheaper attention per token, expert models that only wake a few parts per query, and compressed history for long context. Vendors do not share weights, so read vendor speed claims with care.

By 2026 the big gains moved to test time: who budgets thinking best, and who skips it entirely when a typed answer will do. That is why Fable, Astra, and Jev can feel so different on similar hardware.

For the context-window side, see 1M vs 200K.

Implementation: Find Your Own Best Effort

Do not copy my table. Measure your own tasks. Run each case at every effort level. Record right/wrong, tokens, cost, and time. Pick the cheapest effort that passes.

Background: Low-Effort Routing Policy, Fable High guide, and Do Frontier LLMs Resolve Ambiguity Better (effort does not fix ambiguity — keep your ask-vs-act gate separate).

flowchart TD
    E[Eval set, labeled by task type] --> S[Run each case at low/medium/high/xhigh/max]
    S --> M[Record: correct, tokens, cost, time]
    M --> A[Average per task type]
    A --> U{Accuracy drops at higher effort?}
    U -- Yes on easy tasks --> C[Cap that type at its peak]
    U -- No, still rising --> K[Keep higher effort]
    C --> T[Save per-type effort table]
    K --> T
    T --> R[Router: task type to effort]

Plug your provider call where marked. Keep temperature low so effort is the only thing changing.

from __future__ import annotations

from dataclasses import dataclass
from statistics import mean
import csv
import json

EFFORTS = ["low", "medium", "high", "xhigh", "max"]

@dataclass
class TaskCase:
    id: str
    task_class: str  # e.g. "routine-edit", "multi-file", "ambiguous-plan"
    prompt: str
    check: callable  # (output_text, trace) -> bool

@dataclass
class RunResult:
    case_id: str
    task_class: str
    effort: str
    correct: bool
    thinking_tokens: int
    total_tokens: int
    cost_usd: float
    latency_s: float

def run_once(model: str, effort: str, case: TaskCase) -> RunResult:
    """Call your provider here. Anthropic: output_config={"effort": effort}.
    OpenAI Responses API: reasoning={"effort": effort}.
    Read tokens + cost from the API reply, don't guess."""
    raise NotImplementedError("wire run_once to your provider client")

def sweep(model: str, cases: list[TaskCase], repeats: int = 3) -> list[RunResult]:
    results: list[RunResult] = []
    for effort in EFFORTS:
        for case in cases:
            for _ in range(repeats):
                results.append(run_once(model, effort, case))
    return results

def summarize(results: list[RunResult]) -> dict:
    """Per-class accuracy + cost. Treat 1-2 point gaps as noise."""
    summary: dict = {}
    classes = sorted({r.task_class for r in results})
    for cls in classes:
        per_effort: dict = {}
        for r in results:
            if r.task_class != cls:
                continue
            per_effort.setdefault(r.effort, []).append(r)
        rows = []
        for effort in EFFORTS:
            rs = per_effort.get(effort, [])
            if not rs:
                continue
            acc = mean(1.0 if r.correct else 0.0 for r in rs)
            rows.append({
                "effort": effort,
                "n": len(rs),
                "accuracy": round(acc, 3),
                "mean_total_tokens": int(mean(r.total_tokens for r in rs)),
                "mean_cost_usd": round(mean(r.cost_usd for r in rs), 4),
                "mean_latency_s": round(mean(r.latency_s for r in rs), 1),
            })
        best = max(r["accuracy"] for r in rows)
        peak = next(r for r in rows if r["accuracy"] >= best - 0.01)
        max_row = next(r for r in rows if r["effort"] == "max")
        inverted_u = (peak["accuracy"] - max_row["accuracy"]) > 0.02
        summary[cls] = {
            "rows": rows,
            "recommended_effort": peak["effort"],
            "inverted_u_detected": inverted_u,
        }
    return summary

def emit_table(summary: dict, path_csv: str = "effort-table.csv") -> None:
    with open(path_csv, "w", newline="") as f:
        w = csv.writer(f)
        w.writerow(["task_class", "effort", "n", "accuracy",
                    "mean_tokens", "mean_cost_usd", "mean_latency_s"])
        for cls, s in summary.items():
            for r in s["rows"]:
                w.writerow([cls, r["effort"], r["n"], r["accuracy"],
                            r["mean_total_tokens"], r["mean_cost_usd"],
                            r["mean_latency_s"]])
    with open("effort-policy.json", "w") as f:
        json.dump({cls: {"effort": s["recommended_effort"],
                         "inverted_u": s["inverted_u_detected"]}
                   for cls, s in summary.items()}, f, indent=2)

How to read it:

• Easy tasks should peak early. If routine-edit peaks at low and drops at max, you just reproduced the ACL paper. Cap it. Do not retry at max — fix the prompt instead.
• Hard tasks earn budget. If ambiguous-plan keeps rising through xhigh, pay for it. Still check max separately: it must beat xhigh by a real margin, not noise.
• Small test sets lie. Under ~30 cases per type, treat 1–2 point gaps as noise. Token and cost columns are exact — use them to break ties toward cheaper effort.
• Re-run on every point release. Fable 5 to 5.1 moved the frontier. So did Flash 3.7 to 3.8. A table from July is a rumor in September.

When to Pay for Max

Use this as a starting guess. Let your sweep override it. Every cell is editorial judgment, not a benchmark.

Three rules that survive every sweep:

1. Default to the cheapest effort that passes your tests. Vendor defaults favor demos, not your bill.
2. Escalate with new info, not just more tokens. Re-running the same prompt at max rarely flips the answer. Add a failing test or a doc, then escalate.
3. Re-sweep on point releases. The frontier moves under you.

Sources

Primary sources first. Vendor numbers are vendor-reported September 2026 launch tables unless noted; interpretations are my own.

• Anthropic — Claude Fable 5.1 overview (released Sept 1, 2026): 1M context, 128K out, $10/$50, adaptive always on, default high.
• Anthropic — What’s new in Fable 5.1: breaking changes, per-message effort beta, progress updates beta, cache-read price cut.
• Anthropic — Effort docs: five levels, Fable 5.1 guidance, thinking-vs-effort interaction.
• Anthropic — Introducing Fable 5.1 and Mythos 5.1 (Sept 2026): Low/Medium vs Fable 5, cyber safeguard changes.
• OpenAI — GPT-6 Astra launch (Sept 2026 table): $10/$50 Standard pricing, scores “maximum at any effort”; FrontierMath Tier 4 97.6–98%, ARC-AGI-3 99.9%, T-Bench 4.0 57.9%, DeepSWE 74.1% vs Fable 5.1 67.4% vs Flash 73.8%.
• Google — Introducing Gemini 3.8 Flash (Sept 2, 2026): third Flash in six weeks, $0.75/$3.75 intro pricing, “works harder” diligence note.
• Google DeepMind — Gemini model page (accessed Sept 18, 2026): 3.8 Flash + 3.1 Pro + 3.1 Deep Think lineup, “3.5 Pro coming soon.”
• Google DeepMind — Gemini 3.1 Pro page and 3.1 Deep Think page (Feb 2026 tables): HLE, GPQA, SWE-Verified, Codeforces Elo scores.
• Google DeepMind — Gemini 3.8 Flash model card (Sept 2026 table): DeepSWE 73.7%, T-Bench 2.1 89.4% / 4.0 19.1%, Finance 61.4%, Legal 10.0%, HLE-Verified 54.9%.
• TypeSafe AI — Introducing System One Models and Jev (Sept 14, 2026): System One model class, Jev early access, $0.042/M input and free output, 70–500 ms range, 193.6x faster / 444.6x cheaper workflow claim.
• Flavio Copes — A deep dive into Jev, TypeSafe’s System One model (Sept 17, 2026): jev-1.13.0 / jev-latest / jev-preview aliases, POST /v1/systemone with model + state + questions, Choice/Score/Noul types, Vercel AI Gateway route.
• OmniaKey — What Is the Jev Model? TypeSafe System One AI Explained (fact-checked Sept 19, 2026): 64K context table, 250K tokens/s and 1,200 req/min limits, English-best note, early-access caveats.
• OpenRouter — Jev 1.13 pricing (Sept 18, 2026): $0.042/M in,$0/M out listing.
• ACL Findings 2026 — When More Thinking Hurts: diminishing returns, flip ratios, difficulty-varying optima, cost-aware stopping.
• ICLR 2026 — OptimalThinkingBench: 33-model over/underthinking F1, no model balances both.
• Wu et al. — When More is Less (arXiv 2502.07266): inverted-U, optimal length scales with difficulty, simplicity bias.
• Towards Thinking-Optimal Scaling (arXiv 2502.18080): longer CoTs hurt easy tasks, per-task optimal effort.
• DeepSeek-AI — DeepSeek-V4 (arXiv 2606.19348) (June 2026): MoE + MTP + mHC + CSA/HCA for 1M context.
• NVIDIA — Nemotron-3 Super (arXiv 2604.12374) (April 2026) and Ultra technical report: hybrid Mamba-Attention MoE + LatentMoE + MTP throughput claims.
• Raschka — Recent Developments in LLM Architectures: MLA vs sequence compression summary.
• Artificial Analysis — Gemini 3.8 Flash vs 3.1 Pro Preview (secondary, Sept 2026, Index v4.3 scale): 41 vs 30, 299 vs 121 tok/s, 71k vs 18k output tokens/task.
• BenchLM — GPT-6 Astra benchmarks (secondary, Sept 2026): launch-table snapshot with harness caveats.
• ComputingForGeeks — Astra benchmarks, pricing, API (secondary): five-level latency/cost probe, same-answer finding.
• SynthorAI — Astra reasoning effort (secondary): max 2.3x low cost for same answers on 11 tasks.
• Elser AI — Astra reasoning levels (secondary): none rejected on Astra, mid-conversation configuration_update, routing guidance.

Related in this repo: Fable Low compared, Fable High guide, Low-effort routing policy, How long should a response be, 1M vs 200K context, Do frontier LLMs resolve ambiguity better, CheatBench explainer.