A Battle Among Contenders: Comparing Gemini 4 Carbon, Claude Fable 5.2, and GPT-6 Astra on Overall Capability, Professional Delivery, and Task Cost

Author’s note: This article uses two evaluation systems, the AA Composite Index and the MKA professional task benchmark, to compare Gemini 4 Carbon, Claude Fable 5.2, and GPT-6 Astra on performance, latency, and cost. It also explains the evaluation configurations and where the statistical conclusions do and don’t apply.

Before You Read: 7 Terms Used in the Three-Model Comparison

• MKA (Multimodal Knowledge Agent): A benchmark for multimodal professional work tasks. It tests whether a model can read complex files like drawings, scanned documents, and medical images, and then deliver a complete professional result.
• Climb WSR: A weighted satisfaction rate calculated only over the rubric items that separate models best. It’s used to pull apart the scores of top-tier models.
• Regression WSR: A weighted metric for whether the baseline requirements are met. Think of it as the passing line for professional deliverables.
• Reasoning tier: The reasoning-effort setting a model can run with, such as LOW, MEDIUM, and HIGH for Carbon, or Max and Xhigh for Fable and Astra on the leaderboard.
• Task cost: The total cost of all model invocations needed to finish a given task. It’s not a fixed price for a single API request.
• Cache read: Reusing previously cached input content and billing it at a lower unit price.
• Statistical significance: A measure of whether there’s enough statistical evidence that the score gap between two models is real. If a gap doesn’t reach the significance threshold, you shouldn’t treat it as a definitive win or loss.

Competition among top-tier models is hard to explain with a single composite leaderboard anymore. This article compares Gemini 4 Carbon, Claude Fable 5.2, and GPT-6 Astra across three dimensions (general capability, professional delivery, and task cost), then gives recommendations by task type.

This isn’t a leaderboard recap that mixes every score into one ranking. The composite index and MKA are two separate evaluation systems, so we’ll read them separately. We’ll also point out which gaps have statistical backing and which don’t have enough evidence.

Key takeaway: By the end, you’ll be able to decide which model to reach for first, based on how much your task cares about quality, speed, and cost.

1. Gemini 4 Carbon, Claude Fable 5.2, and GPT-6 Astra Land on the Same Stage

The timing of this round of competition is tightly clustered. Google first announced Gemini 4 Carbon on October 28, 2026, and Anthropic released Claude Fable 5.2 on November 9. Carbon officially opened to developers, enterprises, and consumers on November 10. That same day, Google DeepMind and Artificial Analysis launched the MKA benchmark. On November 11, the Artificial Analysis Intelligence Index v5.0.1 was updated to include Fable 5.2.

The three models are positioned quite differently. Carbon is built on Gemini 4 Argon and targets long-horizon agents, complex software engineering, and scientific research. It accepts text, image, audio, and video input. Fable 5.2 uses Adaptive Thinking, with a 1M-token context window and a maximum output of 128K tokens. GPT-6 Astra has results on both benchmarks cited in this article, and it often serves as the efficiency reference point.

The “Current Verdict” column only applies to the individual metric in each row. No single model ranks first on every dimension.

📊 Data note: The figures above come from an AA leaderboard snapshot and the MKA technical paper. The two use different methodologies, so you can’t convert between them. If you want to validate this against your own use case, you can run a small side-by-side test through APIYI (apiyi.com) using the same prompt, and see how the three models behave under a real workload.

2. AA Overall Leaderboard: Claude Fable 5.2 Leads for Now, Gemini 4 Carbon Close Behind

The Artificial Analysis Intelligence Index v5.0.1 is made up of 9 evaluations: AA-Briefcase v1.1, AutomationBench-AA, Terminal-Bench 4.0, FrontierCode 2.0, AA-Omniscience v1.1, GDP.pdf, HLE-Diamond, CritPt v2, and Terminal-Bench-Science 0.1. Together they cover knowledge work, automation, coding, scientific reasoning, and factual reliability. The question this index answers is: “How strong is the model overall?”

Pay attention to the configuration differences in this table. The three models run at Max, High, and Max tiers respectively, so their reasoning budgets aren’t the same. That means the results aren’t a pure like-for-like comparison of raw capability. Scores also shift when the same model changes tiers: Fable 5.2 scores 62 at both Xhigh and High, while Carbon scores 58 at Medium and 54 at Low.

The tier data inside Carbon deserves its own look. In AA’s measurements, Medium costs $6.59 per task, which is actually lower than Low at $7.19. High has the top score, but its time to first answer token hits 67.54 seconds. In other words, raising the reasoning tier doesn’t necessarily buy you a proportional return. The $7.76 in the table is AA’s average task cost at Carbon’s standard $4/$20 pricing, not the price of a typical single request.

3. MKA Professional Delivery: Can the Three Models Actually Get the Work Done?

The AA Index measures overall capability. MKA measures whether a model can complete real professional work. Here’s how the MKA technical paper sets it up:

• 200 private, real-world tasks covering 10 industries and 83 occupations. Each task represents roughly 3–8 hours of work for a human professional.
• Each task has about 70 weighted grading criteria. 88% of the tasks require the model to produce a standalone file, such as Word, Excel, PPT, PDF, HTML, or an image.
• All models run inside the same Stirrup Agent Harness with an identical tool environment, a uniform budget of 250 turns, and one run per task.

Each of the three metrics means something different. Regression-WSR reflects how well a model meets the baseline requirements. All three score above 95%, with Carbon slightly ahead. Climb-WSR counts only the high-difficulty criteria, and it’s the main way to tell the top models apart. Overall WSR is the weighted satisfaction rate across all criteria. None of these numbers is an accuracy rate on ordinary Q&A, so you can’t line them up against the AA Index scores of 65, 60, and 57.

Statistical Significance: Claude Fable 5.2 vs. Gemini 4 Carbon

Statistical significance is the thing to watch most closely when reading MKA results. Here’s what the paper reports:

• Fable vs. Carbon: Fable leads by 2.22 percentage points, with a 95% confidence interval of -0.94 to +5.49. The interval crosses 0, so the difference isn’t statistically significant.
• Carbon vs. Astra: Carbon leads by 4.10 percentage points, with a 95% confidence interval of +1.00 to +7.11. The interval sits entirely above 0, so the difference is statistically significant.

So the accurate way to put it is this: on MKA, Fable 5.2 and Carbon perform at a similar level, and the current evidence isn’t enough to say Fable clearly beats Carbon. The paper’s conclusion is that both models are significantly ahead of Astra.

4. Task Cost Comparison: What It Actually Costs Each Model to Finish the Same Task

Table 4 of the MKA paper lists the average resource consumption per task. API costs are estimated from each vendor’s list prices, factoring in prompt caching billing.

Three takeaways from this table:

1. Fable puts in the most resources: Its total token count is 5.74x Carbon’s, and its execution time is about 2.85x Carbon’s. Its high-quality results are built on many rounds of exploration and a large number of calls.
2. Carbon has the standout value for money: Its cost per task is about one-sixth of Fable’s, and its Climb-WSR is only 2.22 percentage points lower, a gap that isn’t statistically significant.
3. Astra is the fastest and the most token-efficient: It has the lowest execution time and token consumption, but its cost per task is still slightly higher than Carbon’s, and its Climb-WSR trails Carbon’s significantly.

Token Price vs. Token Consumption vs. Task Bill

People often mix these three concepts up. On token pricing, Fable 5.2 costs $8 per million input tokens and $40 per million output tokens. Carbon’s launch price was $2/$10 until November 30, and it’s $4/$20 from December 1. But a low unit price doesn’t mean a low bill. Astra consumes only about a third of Carbon’s tokens, yet its cost per task is slightly higher. That tells you the price structure and cache hit rate of each model both affect the final charge.

Cache reads are a variable that’s often overlooked in agent scenarios. An agent resends a large amount of context every turn. With Carbon, for example, the cached input price is about 5% of the regular input price. Fable’s total of 40.48M tokens includes a big share of repeatedly read context, so how billing is calculated directly affects the bill. In addition, Carbon’s thinking tokens count toward output charges, and when you use Grounding, search requests are billed separately.

There are three different sources for cost data, and you should cite them separately: Table 4 of the MKA paper (Carbon $5.63, Fable $35.28), the MKA live leaderboard (Carbon $6.29, Fable $31.97), and the AA Index task cost ($7.76, $26.54). Each covers a different scope, so don’t mix them.

5. Where Gemini 4 Carbon’s Multimodal Advantage Shows Up

The MKA paper ran an ablation study: they removed Carbon’s view_image tool and forced it to rely on OCR, code execution, and traditional computer vision methods instead. Here’s what happened:

• Climb-WSR dropped by 5.94 percentage points, and Overall WSR dropped by 4.58 percentage points.
• Agent turns increased by 28%, output tokens by 40%, and input tokens by 85%.
• The model tried to compensate with ASCII art, Unicode Braille, OpenCV, and similar tricks, but it still failed often on real photos and medical images.

These numbers show that visual understanding in professional work is hard to replace with text extraction. Spatial relationships in architectural drawings, lesion locations in medical imaging, and the visual encoding in charts mostly get lost after OCR. The model ends up writing code over and over to guess what’s in the image, so quality goes down and cost goes up.

The industry results on the MKA leaderboard line up with this. Carbon leads in healthcare, and it stands out on image-type deliverables alongside Argon. Fable 5.2 leads in software and data, engineering, logistics and maps, business, and finance, and it does best on deliverable types like PDF, Word, and Spreadsheet. No single model leads across all 10 industries, and Word and plain-text files remain the hardest deliverable types: no model scored above 52% on either.

6. Scenario Recommendations: Where Gemini 4 Carbon, Claude Fable 5.2, and GPT-6 Astra Fit Best

When to Choose Claude Fable 5.2

• Complex professional deliverables where quality matters most: Think financial analysis reports, engineering proposals, and software or data projects. Mistakes are expensive on these tasks, so you can live with longer run times and a bigger bill.
• Office-document-heavy deliverables: PDF, Word, and spreadsheet outputs are where Fable shines in MKA.

When to Choose Gemini 4 Carbon

• Complex Agent work that needs a balance of quality and cost: In MKA, Carbon reached a level statistically close to Fable at roughly one-sixth of the cost.
• Tasks that depend on visual understanding: For example, drawing parsing, medical imaging analysis support, and image-based deliverables. We’d suggest starting with the MEDIUM reasoning level, since it fabricates answers less often in AA’s factual reliability tests.

When to Choose GPT-6 Astra

• Pipelines where execution speed matters: It had the shortest run time and the fewest Agent turns in MKA, which makes it a good fit for tasks that need quick feedback.
• Scenarios sensitive to token budget or context pressure: Astra has the lowest total token consumption, but you’ll have to accept a gap in professional deliverable quality.

7. How to Test the Three Models with a Unified Interface

Public leaderboards are a good starting point, but what really matters is how a model performs on your own tasks. The example below uses an OpenAI-compatible interface, so you can call different models with the same code just by switching the model parameter:

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"  # APIYI's OpenAI-compatible endpoint
)

resp = client.chat.completions.create(
    model="gemini-4-carbon",
    messages=[{"role": "user", "content": "用三点概括这份季度财报摘要的主要风险。"}]
)
print(resp.choices[0].message.content)
print(resp.usage)  # Record token usage, which you'll use later to estimate cost

import time
from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://api.apiyi.com/v1"
)

# Use the model names from the platform's model list; GPT-6 Astra here is just an example name
MODELS = ["claude-fable-5-2", "gemini-4-carbon", "gpt-6-astra"]

# Unit price (USD per million tokens) — fill in according to your actual channel
# Example: Fable 5.2 uses the official list price; Carbon uses the launch price valid until Nov 30
PRICES = {
    "claude-fable-5-2": {"input": 8.0, "output": 40.0},
    "gemini-4-carbon": {"input": 2.0, "output": 10.0},
    "gpt-6-astra": None,  # Fill this in yourself
}

def build_messages(task, image_url=None):
    content = [{"type": "text", "text": task}]
    if image_url:
        content.append({"type": "image_url", "image_url": {"url": image_url}})
    return [{"role": "user", "content": content}]

def run_once(model, messages):
    start = time.time()
    resp = client.chat.completions.create(model=model, messages=messages)
    elapsed = time.time() - start
    usage = resp.usage
    cost = None
    price = PRICES.get(model)
    if price and usage:
        # Rough estimate: doesn't distinguish cache reads; thinking tokens are usually billed as output
        cost = (usage.prompt_tokens * price["input"]
                + usage.completion_tokens * price["output"]) / 1_000_000
    return {
        "model": model,
        "seconds": round(elapsed, 1),
        "prompt_tokens": usage.prompt_tokens if usage else None,
        "completion_tokens": usage.completion_tokens if usage else None,
        "est_cost_usd": round(cost, 4) if cost is not None else None,
        "answer": resp.choices[0].message.content[:200],
    }

if __name__ == "__main__":
    task = "根据这张户型图，列出各房间面积估算和三条改造建议。"
    msgs = build_messages(task, image_url="https://example.com/floor-plan.png")
    for m in MODELS:
        try:
            print(run_once(m, msgs))
        except Exception as e:
            print(m, "调用失败：", e)

This script measures a single call. For a real Agent task, you need to add up the cost across every turn, which is what this article calls task cost. Also note that Carbon doesn’t support thinking_budget — passing it returns an HTTP 400 — and sampling parameters like temperature are ignored. Set the reasoning level the way the platform documentation describes.

🚀 Quick-start tip: Claim the free trial credits for new users at APIYI (apiyi.com) first, then run the comparison script above on 5–10 real business samples. Record latency, token usage, and a quality score before you pick your primary model. The platform gives you access to OpenAI, Claude, Gemini, and other mainstream models with a single API key, billed by usage, and switching models only takes changing one parameter.

Decision Guide: Choosing Among the Three Models

When you’re picking a model, start by identifying the most important constraint for your task, then look at the metric that matches it:

• Quality is a hard constraint: Use MKA’s Climb-WSR as your main reference and choose between Fable 5.2 and Carbon. The gap between them isn’t significant, so it’s best to validate with your own samples.
• Budget is a hard constraint: Look at the per-task cost in MKA Table 4 rather than the per-token price. Carbon has a clear advantage here.
• Speed is a hard constraint: Look at execution time and the number of Agent turns. Astra is the fastest, but you’ll have to accept that it falls significantly behind on professional-grade delivery quality.

💡 Recommendation: Take a page from Google’s /swarm approach: put the strongest model in the planning and review stages, and use a fast model for batch execution. With the unified interface at APIYI (apiyi.com), you can assign different models to different Agent roles within the same project, without having to maintain multiple SDKs.

FAQ

Key Takeaways: Comparing the Three Models

• Overall capability: On AA v5.0.1, Fable 5.2 Max scores 65, ahead of Carbon High at 60 and Astra Max at 57.
• Professional deliverables: On MKA, the gap between Fable and Carbon isn’t significant, and both are well ahead of Astra.
• Cost per task: By the paper’s Table 4 methodology, Carbon costs $5.63 per task, about one-sixth of Fable.
• Speed and efficiency: Astra takes 18.5 minutes and 2.43M tokens per task, making it the best on both speed and token efficiency.
• Multimodal value: With the image-viewing tool removed, Carbon’s quality drops and its input tokens increase by 85%.
• Methodology boundaries: Per-token price, token consumption, and per-task bill are three different things.
• Getting started: You can run a small-sample comparison test across all three models with a single key through APIYI (apiyi.com).

Summary: No Single Metric Decides the Best Model

Back to the question we opened with: the differences among these three top models come down to different trade-offs between quality, speed, and cost.

1. Claude Fable 5.2: Leads on both the overall index and professional deliverable scores, but at the price of the longest execution time and the highest cost per task.
2. Gemini 4 Carbon: Professional deliverable quality is statistically close to Fable’s, it has the lowest cost per task, and its visual understanding is its standout advantage.
3. GPT-6 Astra: The fastest to execute and the most token-efficient, but its professional deliverable quality trails the other two significantly.

Overall capability, task quality, response speed, and cost per task each need to be evaluated separately. Rather than just looking at leaderboard rankings, the more reliable approach is to run a comparison test on your own tasks. We recommend using APIYI (apiyi.com) to quickly check how the three models perform on your workloads. The platform offers free trial credits and a unified multi-model interface.

📚 References

1. MKA Technical Paper: MKA: Evaluating Multimodal Knowledge Agents on end-to-end professional tasks
2. Link: storage.googleapis.com/deepmind-media/papers/mka_tech_paper.pdf

3. Notes: Raw data for the three-model WSR, confidence intervals, Table 4 costs, and the visual ablation experiments

4. Artificial Analysis Model Leaderboard: Intelligence Index v5.0.1

5. Link: artificialanalysis.ai/leaderboards/models

6. Notes: A live snapshot of composite scores, cost per task, and completion time

7. MKA Evaluation Leaderboard: Multimodal Knowledge Agent Rankings

8. Link: artificialanalysis.ai/zh/evaluations/mka

9. Notes: Breakdown results for the industry-leading models and by deliverable file type

10. Gemini 4 Carbon Model Card: Official Google DeepMind documentation

11. Link: deepmind.google/models/model-cards/gemini-4-carbon

12. Notes: Modalities, context, reasoning tiers, and known limitations

13. Gemini API Pricing Page: Carbon standard, cached, and Batch pricing

14. Link: ai.google.dev/gemini-api/docs/pricing

15. Notes: Launch pricing and the price adjustment taking effect on December 1

16. Claude Fable 5.2 API Documentation: Official Anthropic model overview

17. Link: platform.claude.com/docs/en/models/fable-5-2/overview
18. Notes: Context, max output, per-token pricing, and Fast Mode

Author: APIYI Technical Team
Get in touch: Reach out to us on the APIYI website homepage. For more integration resources, visit the docs.apiyi.com documentation center.

Related Articles

• Fable 5.5 vs GPT-6.2 Astra: Which Is More Powerful and How to Choose? 6 Demos and 3 Unfair Comparisons: Fable 5.5 and GPT-6.2 Astra both have public demos but no head-to-head comparison; this article assesses evidence levels for six demos, reviews official specs and pricing for current flagships Fable 5.1 and GPT-6 Astra, and provides a reproducible model selection method.
• Claude Fable 5.2 vs. Claude Opus 5.5: How to Choose: Claude Fable 5.2 vs. Claude Opus 5.5: At twice the standard price, it doesn’t win in every category; this article offers a task-based model selection table covering specs, pricing, default effort level, and release benchmark results.
• Breaking Down 230 Million Legal URLs: Does Astra for Law’s Expertise Come from the Model or Its Legal Search Index?: Based on official disclosures, examine Astra for Law’s legal search index of 230 million URLs, its 54.0% test score, and API pricing to clarify the sources of its legal expertise and what remains unverified.
• How Capable Is Claude Fable 5.2? Four Boundaries in Coding and Long Tasks: Using the official results and limitations in Anthropic’s release post, explain what Claude Fable 5.2 excels at, where its strengths end, and when you shouldn’t switch from Opus 5.5.
• Claude Fable 5.2 Is Here: High or Max? Let’s Put It to the Test for Quality and Cost: Public evaluations show that raising Claude Fable 5.2’s reasoning tier from high to max may improve scores but also increase per-task costs, so the tier should be chosen based on both the task’s quality threshold and budget.
• Learn to Break Down Model Capability Claims from the Astra Qwen Weight Modification Controversy: A 6-Step Verification Checklist: Using the controversy over GPT-6 Astra rewriting Qwen3.5-0.8B weights as a case study, break down model capability claims in six steps to understand baselines, tool permissions, evaluation settings, and reproducibility evidence.
• Claude Ranks First, Gemini Costs Less Than a Third: Comparing Value for Money Across 13 Models in GDPx: Analyze the inaugural GDPx leaderboard published by SemiAnalysis, comparing the scores and “average task costs” of Claude Opus 5.5, Gemini 4 Carbon, GPT-6 Astra, Sol, Luna, and DeepSeek, and distinguish evaluation costs from official token prices.
• Claude Fable 5.2, you orchestrated 1,000 agents to build the system—impressive, but how do you calculate the API costs?: Using a hypothetical workflow, break down model pricing, caching, Session Runtime, tool costs, and 30-day data retention requirements in the Claude Fable 5.2 multi-agent system.
• Gemini 4 Carbon Release Analysis: Scores 59 to Overtake Opus 5.5, Wins 15 of 17 Tests but Remains Inaccessible: Gemini 4 Carbon topped the Artificial Analysis Intelligence Index with 59 points and won 15 of 17 official comparisons, but has no API model ID or release timeline; this article breaks down the scores, explains why it is unavailable, and suggests gemini-4-argon for Chinese developers.