# Frontier models compared: GPT-6, Fable 5.1, Gemini, Grok

URL: https://infro.io/blog/frontier-models-compared-2026
Author: INFRO Editorial (https://infro.io/blog/editorial)
Publisher: INFRO
Published: 2026-09-29
Last modified: 2026-09-29
Last reviewed: 2026-09-29 (next review due 2026-10-29)
Topic: Evaluation and models
Format: Comparison

> On published facts, GPT-6 Astra and Claude Fable 5.1 share a $10 input and $50 output list rate per million tokens, Gemini 3.1 Pro (still a preview) lists $2 and $12, and Grok 4.7 lists $2 and $6, with different context windows, output limits and long-prompt surcharges. None of that says which model does your task well: evaluate each on your own tasks, compare cost per successful task, and route each task tier to the lowest-cost model that passes.

Key takeaways:
- GPT-6 Astra and Claude Fable 5.1 have the same standard input and output list rates; caching and long-prompt rules are where their bills diverge.
- Gemini 3.1 Pro is a preview model, and Grok 4.7 has a 500K window, half the others; check both facts before designing around them.
- Every vendor here reprices long prompts differently: above 272K, 200K or not at all. Know where your prompt sizes sit.
- List rates price tokens, not outcomes. Cost per successful task on your own eval set is the comparison that decides.
- Run candidates behind one route so the application never changes and every attempt is recorded with its estimated provider cost.

Four model families sit at the top of their vendors' price lists this autumn: OpenAI's GPT-6 Astra, Anthropic's Claude Fable 5.1, Google's Gemini 3.1 Pro and xAI's Grok 4.7. Comparisons of them tend to lead with benchmark charts. This one leaves benchmarks out and compares only what each vendor publishes about its own model — the facts that decide whether a model can run your workload at all, and what your provider will bill for it. Then it gives a method for the question the facts cannot answer: which one does your task well enough.

Every rate below is the vendor's own list rate, read on 2026-09-29. If your organization has negotiated rates with a provider, those are what you pay; the list rate is a reference point.

## The four models on one page

GPT-6 Astra is described by OpenAI as its most capable model, built for the hardest end-to-end work[1]. Claude Fable 5.1 is Anthropic's model for demanding reasoning and long-horizon agentic work[2]. Gemini 3.1 Pro is published under the preview codes `gemini-3.1-pro-preview` and `gemini-3.1-pro-preview-customtools`, the second tuned for agentic work with custom tools and bash[3]. Grok 4.7 is served as `grok-4.7`, with a 500K-token context window and reasoning effort from `low` to `xhigh`[4].

[Diagram: What each vendor publishes about its own model, read 2026-09-29. "Not listed" means the vendor page did not state it, not that the model lacks it.]

Three facts in that grid deserve attention before anything else:

- **Gemini 3.1 Pro is a preview.** Its model codes carry `-preview`[3]. That is a lifecycle fact, not a quality one, and it belongs in any production decision.
- **Output limits differ by a factor of two.** Astra and Fable 5.1 both allow 128K output tokens[5][2]; Gemini 3.1 Pro allows 65,536[3]. Long generated documents or large code edits can hit the lower limit.
- **Grok 4.7's window is 500K**[4], where the other three sit near one million. Astra's 1.05M window accepts at most 922K input tokens[5].

All four accept images alongside text; Gemini 3.1 Pro also takes video, audio and PDF input[3]. All four support function calling and structured outputs according to their vendors[5][6][3][4].

## List rates

[Diagram: Standard-tier list rates per million tokens, from each vendor's pricing page on 2026-09-29. Gemini and Grok rates are for prompts under their long-prompt thresholds.]

Astra and Fable 5.1 list the same rates: $10 per million input tokens and $50 per million output tokens[7][8]. Gemini 3.1 Pro lists $2 input and $12 output for prompts up to 200K tokens[9]. Grok 4.7 lists $2 input and $6 output under 200K[10]. See each model's reference page for the catalog entry INFRO estimates against: [GPT-6 Astra](https://infro.io/models/openai/gpt-6-astra), [Claude Fable 5.1](https://infro.io/models/anthropic/claude-fable-5.1), [Gemini 3.1 Pro](https://infro.io/models/google/gemini-3.1-pro) and [Grok 4.7](https://infro.io/models/xai/grok-4.7).

A per-token rate is only half of a comparison, because the models do not produce the same number of tokens for the same work. A model that thinks longer, writes longer answers or needs a second attempt costs more per task at the same rate. That is why the method at the end divides by successful tasks, not by tokens.

## Where the bills diverge: caching and long prompts

Two published rules change a bill more than the headline rate for many production workloads.

**Cached input.** Agents and assistants resend the same system prompt, tool definitions and history on every call, so cached-input pricing often decides the input bill. Fable 5.1 bills cache hits at 0.025x input, $0.25 per million, with 5-minute cache writes at $12.50 and 1-hour writes at $20[8]. Astra lists cached input at $1.00 and cache writes at $12.50[7]. Gemini 3.1 Pro lists context caching at $0.20 per million for prompts up to 200K, plus $4.50 per million tokens per hour of storage[9]. Grok 4.7 lists cached input at $0.50 below 200K[4].

**Long prompts.** Each vendor treats a large prompt differently:

| Model | Threshold | What changes |
| --- | --- | --- |
| GPT-6 Astra | More than 272K input tokens | 2x input and cache rates, 1.5x output, for the full request[7] |
| Claude Fable 5.1 | None | The full 1M window is billed at the standard rate[8] |
| Gemini 3.1 Pro | More than 200K prompt tokens | $4 input, $18 output per million[9] |
| Grok 4.7 | 200K prompt tokens or more | Higher rate for all tokens in the request[10] |

Table: Long-prompt pricing rules as published on 2026-09-29.

> **Example: A 400K-token document review**
> Illustrative. A request sends 400,000 input tokens and receives 5,000 output tokens, with no caching. On Fable 5.1 at the standard rate: 0.4 × $10 + 0.005 × $50 = $4.25. On Astra, above 272K the whole request bills at 2x input and 1.5x output: 0.4 × $20 + 0.005 × $75 = $8.375. On Gemini 3.1 Pro above 200K: 0.4 × $4 + 0.005 × $18 = $1.69. On Grok 4.7, at 200K or more the whole request bills at 2x: 0.4 × $4 + 0.005 × $12 = $1.66, with 100K tokens of its 500K window to spare. The ordering can flip again once caching and retries enter, which is why the method below measures real runs.

## Other published options that affect cost

- **Batch.** OpenAI lists Astra's batch and flex tiers at $5 input and $25 output[7]; Anthropic lists Fable 5.1 batch at the same $5 and $25[8]; Google lists Gemini 3.1 Pro batch at $1 and $6 below 200K[9]. Batch suits work nobody is waiting for.
- **Location.** Anthropic applies a 1.1x multiplier when you pin inference to the US with `inference_geo`[8]. OpenAI charges a 10% uplift on regional processing endpoints for models released on or after March 5, 2026[7]. If your contracts require a region, compare the uplifted rates.
- **Knowledge cutoff.** Astra's is April 30, 2026[5]; Fable 5.1's reliable knowledge cutoff is June 2026[2]. It matters for tasks that depend on recent facts without retrieval.

## What this comparison cannot tell you

No table of published facts says which model writes the better contract summary, fixes the harder bug or follows your tool schema more reliably on your data. Vendors publish benchmark results for their own models, but a benchmark measures a benchmark. Your prompts, your tools, your documents and your definition of a correct answer are different, and differences in output length and retry rate change the real cost per task as much as the rate card does. See [evaluating models on real workloads](https://infro.io/blog/evaluate-llms-real-workloads) for how to build the evaluation set.

## A method for choosing

[Diagram: Four steps from published facts to a routing decision. The facts filter; your own evaluation decides.]

1. **Shortlist on facts.** Remove any model that cannot run the task: too small a window, too low an output limit, a missing modality, a data-location option you need, or a preview status your policy rejects.
2. **Build an eval set from real traffic.** Fifty to a few hundred real inputs per task type, each with a check a machine or a reviewer can apply: schema valid, test suite passes, answer matches the reference.
3. **Run every candidate on the same inputs** through the same client, recording each request's estimated provider cost and outcome.
4. **Compute cost per successful task** — total estimated cost for the model divided by the number of tasks it passed — and route each task tier to the lowest-cost model that meets your pass rate. The companion piece on [cost per successful task](https://infro.io/blog/cost-per-successful-task) goes deeper on the metric.

> **Example: Cost per successful task**
> Illustrative. On 200 extraction tasks, model A costs an estimated $0.030 per request and passes 180; model B costs $0.012 and passes 120. A: $6.00 ÷ 180 = $0.033 per success. B: $2.40 ÷ 120 = $0.020 per success, but 80 tasks need a second attempt somewhere. If B's failures are retried on A and A passes them, the blended cost is $2.40 + 80 × $0.030 = $4.80 for 200 successes, $0.024 each. The lowest cost per request is not automatically the lowest cost per result, and neither is the highest.

## Running the comparison through INFRO routes

INFRO does not score answers; your eval harness does. What INFRO contributes is one endpoint for every candidate on your own provider accounts, a record of each request, and an estimate of what your provider will bill for it.

Connect each provider account you want to test under [Providers](https://infro.io/docs/providers) — OpenAI, Anthropic, Google AI (Gemini) and xAI each have a connection kind. Then call each candidate by its catalog id through the OpenAI-compatible endpoint, tagging the run so its requests can be grouped later:

```python
import os
from openai import OpenAI

client = OpenAI(api_key=os.environ["INFRO_API_KEY"], base_url="https://api.infro.io/v1")

CANDIDATES = [
    "openai/gpt-6-astra",
    "anthropic/claude-fable-5.1",
    "google/gemini-3.1-pro",
    "xai/grok-4.7",
]

def run(task, model):
    resp = client.chat.completions.create(
        model=model,
        messages=task["messages"],
        extra_body={"metadata": {"workflow": "frontier-eval", "feature": task["kind"]}},
    )
    usage = resp.usage.model_dump()
    return {
        "request_id": resp.id,             # INFRO request id, req_...
        "model": resp.model,               # the model that actually served
        "passed": task["check"](resp.choices[0].message.content),
        "cost": usage.get("cost"),         # estimated provider cost; None if unpriced
    }
```

`usage.cost` is an estimate of what your provider will bill, and `usage.price_source` says whether it came from the list rate or from a rate you entered. Totals for the run come from `GET /v1/usage?group_by=model&from=...&to=...`, which returns requests, cost, unpriced requests, error rate and p50/p95 latency per model ([usage analytics](https://infro.io/docs/observability/analytics)); individual requests are in `GET /v1/requests?workflow=frontier-eval` ([request traces](https://infro.io/docs/observability/traces)).

Two cautions. First, the catalog carries one rate per model, so a request above a vendor's long-prompt threshold is estimated at the base rate and reads low; if your prompts cross those thresholds, enter your own rate under Prices ([billing](https://infro.io/docs/org/billing)) or compare against the provider's invoice. Second, if you have negotiated rates, enter them too, or the comparison will rank list prices you do not pay.

Once you have decided, put the choice behind a [route](https://infro.io/docs/routes): a stable name such as `contract-review` whose ordered targets name the chosen model first and a tested alternative second. The application keeps sending `"model": "contract-review"`; changing the model is a console edit, and every request's trace names the connection and model that served it. A `weighted` route can also send a small share of live traffic to a challenger, but it still falls through to other targets on failure, so group results by the model that served, not by which target was picked first ([routing](https://infro.io/docs/features/routing)).

Your providers bill your accounts directly for every one of these requests, at your rates. INFRO's subscription is separate and is not priced per token.

## Questions

### Is GPT-6 Astra or Claude Fable 5.1 better for coding?

Neither vendor's documentation answers that for your codebase, and this comparison does not rank them. Run both on a set of real tasks from your repository with a pass/fail check such as the test suite, then compare the estimated provider cost of each passing task.

### Can I use Gemini 3.1 Pro in production while it is a preview?

Google lists it under preview model codes. Read Google's terms for preview models before depending on one, and keep a tested alternative target on the same route so a change to the preview does not become an outage.

## Sources

1. Models — OpenAI. https://developers.openai.com/api/docs/models (accessed 2026-09-29)
2. Models overview — Anthropic. https://platform.claude.com/docs/en/about-claude/models/overview (accessed 2026-09-29)
3. Gemini 3.1 Pro Preview — Google. https://ai.google.dev/gemini-api/docs/models/gemini-3.1-pro-preview (accessed 2026-09-29)
4. Grok 4.7 — xAI. https://docs.x.ai/docs/models/grok-4.7 (accessed 2026-09-29)
5. GPT-6 Astra — OpenAI. https://developers.openai.com/api/docs/models/gpt-6-astra (accessed 2026-09-29)
6. Structured outputs — Anthropic. https://platform.claude.com/docs/en/build-with-claude/structured-outputs (accessed 2026-09-29)
7. Pricing — OpenAI. https://developers.openai.com/api/docs/pricing (accessed 2026-09-29)
8. Pricing — Anthropic. https://platform.claude.com/docs/en/about-claude/pricing (accessed 2026-09-29)
9. Gemini Developer API pricing — Google. https://ai.google.dev/gemini-api/docs/pricing (accessed 2026-09-29)
10. Models and pricing — xAI. https://docs.x.ai/docs/models (accessed 2026-09-29)