Claude vs Gemini: AI Model Comparison (2026)

Claude excels at reasoning and coding — Gemini excels at multimodal and large-context tasks. That’s the core trade-off. Claude (Anthropic) consistently produces more structured, reliable outputs on complex prompts, while Gemini (Google) processes images, video, and audio natively and offers a 2M-token context window — 10x Claude’s 200K. Both are serious GPT-4 alternatives, and the best choice depends entirely on what you’re building.

Who this is for:

Junior engineers: You’re evaluating AI providers for a project and need to understand how Claude and Gemini differ in practice — not just on paper
Senior engineers: You’re designing a multi-model architecture and need to know exactly where each provider has a defensible advantage

Real-World Problem Context

You’re building an AI-powered feature and need to pick a model provider. OpenAI is the default everyone knows, but Claude and Gemini have emerged as the two strongest alternatives — each with distinct advantages. Here’s where the choice actually matters:

Scenario	Claude Wins	Gemini Wins	Why
Code review agent	Strong reasoning catches subtle bugs	—	Claude’s instruction following and code understanding are measurably superior
Video content analysis	—	Native video understanding, no frame extraction needed	Gemini was trained multimodal from the ground up
Contract analysis (200-page PDF)	—	2M context fits the entire document	Claude’s 200K context may require chunking for very long documents
RAG system with precise citations	Structured outputs, faithful to retrieved context	—	Claude hallucinates less on grounded tasks
Customer support chatbot	Better nuanced, on-brand responses	Cheaper at high volume with Flash	Claude follows system prompts more reliably; Gemini Flash costs 8x less than Haiku
Image-heavy product catalog	—	Native image understanding, faster processing	Gemini’s multimodal pipeline is more efficient
Complex multi-step agent	Superior tool calling and planning	—	Claude’s agentic capabilities consistently rank highest in benchmarks

The real question isn’t “which model is better” — it’s “which model is better for your specific task.” Teams that benchmark on their actual data before choosing save thousands in wasted API costs and avoid painful mid-project migrations.

Core Concepts and Mental Model

Claude and Gemini represent fundamentally different approaches to AI development. Understanding the philosophies behind each helps you predict where they’ll excel.

Anthropic’s Claude: Safety-First Reasoning

Anthropic was founded by former OpenAI researchers with a focus on AI safety. This philosophy shows up in Claude’s behavior:

Constitutional AI — Claude is trained with explicit behavioral principles, which makes it more predictable and controllable with system prompts
Strong instruction following — Claude adheres closely to complex, multi-step instructions without drifting
Reasoning depth — The model family prioritizes getting the answer right over getting it fast
200K context window — Large enough for most use cases, but not the largest available

The Claude model family follows a clear capability/cost spectrum:

Claude Opus 4 — Maximum intelligence. The hardest reasoning tasks, complex code architecture, novel analysis. Premium pricing.
Claude Sonnet 4 — Balanced performance. The default for most production applications. Strong reasoning at moderate cost.
Claude Haiku 4.5 — Speed and cost optimized. High-volume tasks where fast responses and low cost matter more than peak capability.

Google’s Gemini: Multimodal-Native Scale

Google built Gemini as a natively multimodal model — text, images, audio, and video are processed in the same architecture from the start, not bolted on after text training. This gives Gemini structural advantages:

Native multimodal — Images, video, and audio are first-class inputs, not converted to text descriptions
Massive context window — Up to 2M tokens means you can pass entire codebases, hour-long videos, or hundreds of documents in a single call
Google ecosystem integration — Deep integration with Vertex AI, Google Cloud, and Google Workspace
Aggressive pricing — Gemini Flash is one of the cheapest capable models available

The Gemini model family mirrors Claude’s tiered structure:

Gemini 2.0 Ultra — Maximum capability. Complex multimodal reasoning, the hardest tasks. Premium pricing.
Gemini 2.0 Pro — Balanced performance. Strong across text and multimodal tasks at moderate cost.
Gemini 2.0 Flash — Speed and cost optimized. Extremely cheap, fast, handles most simple tasks well.

Model Tier Comparison

Tier	Claude	Gemini	Primary Difference
Premium	Opus 4	2.0 Ultra	Claude: deeper reasoning. Gemini: stronger multimodal.
Balanced	Sonnet 4	2.0 Pro	Claude: better code/instruction following. Gemini: larger context, cheaper.
Budget	Haiku 4.5	2.0 Flash	Gemini Flash is ~8x cheaper on input tokens. Both fast.
Context window	200K tokens (all tiers)	Up to 2M tokens	Gemini has a 10x larger context capacity
Multimodal	Text + images	Text + images + video + audio	Gemini handles more modalities natively
API style	Messages API	GenerateContent API	Both support streaming, tool calling, system instructions

For a deeper comparison of Claude models specifically, see Claude Sonnet vs Haiku.

Step-by-Step: Choosing the Right Model

Follow this decision framework to select the right provider and tier for your use case.

The Decision Framework

Use this sequence to select the right provider and model:

Does your task involve video or audio input?
- Yes — Use Gemini (Claude doesn’t process video/audio natively)
- No — Continue to step 2
Does your task require >200K tokens of context?
- Yes — Use Gemini (2M context window)
- No — Continue to step 3
Is the primary task complex reasoning, coding, or strict instruction following?
- Yes — Use Claude (measurably stronger on these tasks)
- No — Continue to step 4
Is cost the primary constraint? (high volume, simple tasks)
- Yes — Use Gemini Flash ($0.10/M input tokens — cheapest option)
- No — Continue to step 5
Do you need deep Google Cloud / Vertex AI integration?
- Yes — Use Gemini (native Vertex AI support)
- No — Continue to step 6
Do you need AWS Bedrock integration?
- Yes — Use Claude (available as a first-party model on Bedrock)
- No — Default to Claude Sonnet for general-purpose tasks or Gemini Pro for multimodal-heavy workloads

Pricing Comparison (Current)

Model	Input (per M tokens)	Output (per M tokens)	Context Window	Max Output
Claude Opus 4	$15	$75	200K	32K
Claude Sonnet 4	$3	$15	200K	16K
Claude Haiku 4.5	$0.80	$4	200K	8K
Gemini 2.0 Ultra	$7	$21	2M	8K
Gemini 2.0 Pro	$1.25	$5	2M	8K
Gemini 2.0 Flash	$0.10	$0.40	1M	8K

At the budget tier, Gemini Flash is 8x cheaper than Claude Haiku on input and 10x cheaper on output. At the balanced tier, Gemini Pro is roughly 2.4x cheaper on input than Claude Sonnet. The gap narrows at the premium tier.

API Code: Claude vs Gemini Side by Side

Claude (Anthropic SDK):

import anthropic

client = anthropic.Anthropic()  # Uses ANTHROPIC_API_KEY env var

response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    system="You are a helpful code reviewer. Be concise and specific.",
    messages=[
        {"role": "user", "content": "Review this function for bugs:\n\ndef calculate_average(numbers):\n    return sum(numbers) / len(numbers)"}
    ]
)

print(response.content[0].text)
# "The function will raise a ZeroDivisionError if `numbers` is empty.
#  Add a guard: if not numbers: return 0 (or raise ValueError)."

Gemini (Google GenAI SDK):

import google.generativeai as genai

genai.configure()  # Uses GOOGLE_API_KEY env var

model = genai.GenerativeModel(
    model_name="gemini-2.0-pro",
    system_instruction="You are a helpful code reviewer. Be concise and specific."
)

response = model.generate_content(
    "Review this function for bugs:\n\ndef calculate_average(numbers):\n    return sum(numbers) / len(numbers)"
)

print(response.text)

The APIs follow similar patterns — system instructions, message-based input, structured output. The key differences are in the SDK naming conventions and response structure, not in the interaction model.

Tool calling (function calling) works in both:

# Claude tool definition
tools_claude = [{
    "name": "get_weather",
    "description": "Get current weather for a location",
    "input_schema": {
        "type": "object",
        "properties": {
            "location": {"type": "string", "description": "City name"}
        },
        "required": ["location"]
    }
}]

# Gemini tool definition
tools_gemini = [genai.protos.Tool(
    function_declarations=[{
        "name": "get_weather",
        "description": "Get current weather for a location",
        "parameters": {
            "type": "object",
            "properties": {
                "location": {"type": "string", "description": "City name"}
            },
            "required": ["location"]
        }
    }]
)]

Both support structured tool calling with JSON schemas. Claude tends to follow tool-use instructions more precisely in complex multi-tool scenarios, while Gemini offers a slightly simpler tool definition format.

Architecture and System View

The diagrams below visualize where each provider has a structural advantage and which task categories each handles best.

📊 Claude vs Gemini Head-to-Head

Claude vs Gemini — Strengths and Weaknesses

Claude (Anthropic)

Reasoning, coding, and instruction following

Superior complex reasoning and multi-step logic
Best-in-class code generation and review
Reliable instruction following with system prompts
Strong safety and refusal calibration
200K context window (10x smaller than Gemini)
No native video or audio input support

Gemini (Google)

Multimodal, large context, Google ecosystem

Native multimodal — images, video, audio, text
2M token context window (10x larger than Claude)
Gemini Flash is the cheapest capable model available
Deep Google Cloud and Vertex AI integration
Weaker at complex reasoning and strict instruction following
Less predictable on nuanced, multi-step prompts

Verdict: Use Claude when reasoning, coding, and instruction following matter most. Use Gemini when you need multimodal, large context, or the lowest possible cost. Use both with a model router for optimal cost and quality.

Use case

Choosing between Claude and Gemini for production AI applications

📊 Use Case Selection Guide

Model Selection by Use Case

Route each task type to the provider with the strongest advantage

Task Analysis

Classify your workload

Identify primary input modality

Estimate context length needed

Determine reasoning complexity

Calculate expected request volume

Claude-Optimal Tasks

Reasoning and code-heavy work

Code generation and review

Complex multi-step analysis

Agentic tool-calling workflows

Structured data extraction with strict schemas

Gemini-Optimal Tasks

Multimodal and scale work

Video and audio understanding

Large-document processing (>200K tokens)

Image-heavy classification pipelines

High-volume simple tasks (Flash pricing)

Either Provider

Benchmark on your specific data

General text summarization

Standard chatbot conversations

Simple classification and labeling

Translation and content generation

Idle

Practical Examples

The most effective production pattern is a model router that sends each task type to the provider with the highest quality-to-cost ratio for that specific workload.

Multi-Provider Model Router

The most common production pattern is routing requests to the optimal provider based on task type:

import anthropic
import google.generativeai as genai

claude_client = anthropic.Anthropic()
genai.configure()
gemini_model = genai.GenerativeModel("gemini-2.0-flash")

# Task-to-provider mapping
CLAUDE_TASKS = {"code_review", "reasoning", "analysis", "agent", "extraction"}
GEMINI_TASKS = {"multimodal", "video", "large_context", "classification_bulk"}

def route_request(task_type: str, prompt: str, **kwargs) -> str:
    """Route to the optimal provider based on task type."""

    if task_type in GEMINI_TASKS:
        response = gemini_model.generate_content(prompt)
        return response.text

    elif task_type in CLAUDE_TASKS:
        model = "claude-sonnet-4-20250514"
        response = claude_client.messages.create(
            model=model,
            max_tokens=kwargs.get("max_tokens", 1024),
            messages=[{"role": "user", "content": prompt}]
        )
        return response.content[0].text

    else:
        # Default: use Gemini Flash for cost efficiency on unknown tasks
        response = gemini_model.generate_content(prompt)
        return response.text

# Code review → Claude (reasoning strength)
review = route_request("code_review", "Review this PR diff for bugs:\n...")

# Image classification → Gemini (multimodal strength)
label = route_request("multimodal", "What product category is this image?")

# Unknown task → Gemini Flash (cheapest default)
result = route_request("other", "Summarize this paragraph: ...")

Context Window: When Size Matters

Gemini’s 2M-token context window is its most defensible technical advantage. Here’s where it changes what’s possible:

import google.generativeai as genai

genai.configure()
model = genai.GenerativeModel("gemini-2.0-pro")

# Load an entire codebase into context (impossible with 200K models)
with open("full_codebase.txt") as f:
    codebase = f.read()  # 800K tokens — fits in Gemini, not in Claude

response = model.generate_content(
    f"Analyze this entire codebase for security vulnerabilities. "
    f"List every SQL injection, XSS, and auth bypass risk:\n\n{codebase}"
)

With Claude, you’d need a chunking strategy — split the codebase into segments, process each with a summarization pass, then synthesize. Gemini handles it in one call. The trade-off: Gemini’s analysis of that 800K-token input may be less thorough than Claude analyzing smaller, focused chunks.

Benchmark Results by Task Type

Task Category	Claude Sonnet 4	Gemini 2.0 Pro	Winner	Margin
Code generation (HumanEval+)	92%	85%	Claude	+7%
Multi-step reasoning (GPQA)	68%	62%	Claude	+6%
Instruction following (IFEval)	91%	84%	Claude	+7%
Image understanding (MMMU)	70%	74%	Gemini	+4%
Video QA (VideoMME)	N/A	72%	Gemini	N/A
Long-context retrieval (NIAH 1M)	N/A	99.2%	Gemini	N/A
Math reasoning (MATH)	78%	76%	Claude (slight)	+2%
General knowledge (MMLU)	89%	88%	Tie	+1%
Tool use accuracy	94%	87%	Claude	+7%

The pattern: Claude leads on reasoning, coding, and tool use by 5-7%. Gemini leads on multimodal and large-context tasks. On general knowledge and math, they’re within noise of each other.

Cost at Scale: Real Workload Examples

Workload	Monthly Volume	Claude Sonnet Cost	Gemini Pro Cost	Gemini Flash Cost
Customer support chatbot	500K messages	~$2,250	~$940	~$75
Document classification	1M documents	~$4,500	~$1,875	~$150
Code review agent	50K reviews	~$1,125	~$470	Quality too low
Video content moderation	100K videos	N/A (not supported)	~$1,250	~$100
Long-doc summarization	200K docs (avg 500K tokens)	Requires chunking	~$1,562	~$125

Estimates based on average token usage per task. Actual costs vary by prompt length and response size.

The cost story is nuanced. For simple, high-volume tasks, Gemini Flash is 10-30x cheaper than Claude Sonnet. For tasks where quality matters (code review, complex analysis), Claude’s higher cost is justified by significantly better output.

Trade-offs, Limitations and Failure Modes

Common Mistakes

Choosing based on context window alone — Gemini’s 2M context is impressive, but most applications don’t need >100K tokens. If your average prompt is 5K tokens, the context window difference is irrelevant. Choose based on output quality for your task, not theoretical input capacity.
Ignoring the multimodal gap — If your application processes images, video, or audio, Gemini has a structural advantage. Claude supports image input but not video or audio. Trying to work around this with frame extraction and transcription adds complexity, cost, and latency.
Assuming Claude is always better at reasoning — Claude leads on aggregate benchmarks, but Gemini Pro outperforms Claude Sonnet on some specific reasoning subtasks, especially those involving spatial reasoning or multimodal inference. Always test on your specific task.
Locking into a single provider — Both APIs are similar enough that abstracting behind an interface costs very little engineering effort. Single-provider lock-in means you can’t take advantage of price drops, new model releases, or task-specific strengths.
Using premium models for simple tasks — Claude Opus at $15/M input or Gemini Ultra at $7/M input for basic classification is wasteful. Start with the cheapest model (Gemini Flash at $0.10/M) and only upgrade when you measure a meaningful quality gap.
Ignoring rate limits and availability — Both providers have rate limits that differ by model and tier. Google’s free tier is generous for prototyping. Anthropic’s rate limits scale with usage tier. Plan for both in your architecture.
Forgetting ecosystem costs — The API cost is only part of the total. Claude via AWS Bedrock adds AWS infrastructure costs. Gemini via Vertex AI adds Google Cloud costs. Factor in the full stack, not just per-token pricing.

Interview Perspective

These questions test whether you can reason about provider selection with technical evidence rather than brand preference.

Q1: “How would you decide between Claude and Gemini for a production application?”

What they’re testing: Can you reason about provider selection systematically rather than defaulting to “whatever’s popular”?

Strong answer: “I’d start by characterizing the workload along four dimensions: primary modality (text-only vs multimodal), context length requirements, reasoning complexity, and volume. For text-heavy reasoning tasks like code review or complex analysis, Claude has a measurable advantage — roughly 5-7% higher accuracy on benchmarks. For multimodal tasks involving video or audio, Gemini is the only viable option between the two. For high-volume simple tasks, Gemini Flash at $0.10/M tokens is 8x cheaper than Claude Haiku. I’d prototype with both providers on 100+ real examples from our data, measure quality and latency, then build an abstraction layer that lets us route to either.”

Q2: “Your team is building a document analysis pipeline that processes 100-page PDFs. The CTO wants to use Claude because ‘it’s the best at reasoning.’ Do you agree?”

What they’re testing: Can you push back with technical evidence and propose a nuanced solution?

Strong answer: “Partially. Claude is stronger at reasoning, but we need to consider context length. A 100-page PDF is roughly 50-80K tokens — well within Claude’s 200K window, so context isn’t an issue here. However, if the pipeline also needs to process scanned documents with embedded images, Gemini’s native multimodal capability would avoid the OCR preprocessing step that Claude requires. My recommendation: use Claude Sonnet for the reasoning-heavy extraction and analysis, but test Gemini Pro as well. If the PDFs are text-heavy, Claude likely wins. If they contain charts, diagrams, or scanned pages, Gemini may produce better results with less preprocessing.”

Q3: “What are the risks of building on a single LLM provider?”

What they’re testing: Production thinking — reliability, vendor risk, and architecture foresight.

Strong answer: “Single-provider dependency creates three risks. First, availability: if Anthropic or Google has an outage, your entire AI feature goes down. Second, pricing: providers adjust pricing as they scale, and without alternatives you have no leverage. Third, capability gaps: no single model is best at everything, so you’re leaving performance on the table. The mitigation is a model abstraction layer — a thin interface that routes requests to providers based on task type. Both Claude and Gemini support similar API patterns (messages, tool calling, streaming), so the abstraction cost is low. In production, I’d implement primary/fallback routing: Claude for reasoning tasks with Gemini as fallback, Gemini for multimodal with Claude (images only) as degraded fallback.”

Production Perspective

Here’s how engineering teams use Claude and Gemini together in production systems:

Multi-model routing is becoming standard. The era of picking one model for everything is ending. Teams at scale route reasoning-heavy tasks (code generation, complex analysis, agent loops) to Claude and multimodal or high-volume simple tasks to Gemini. The router can be as simple as a task-type lookup or as sophisticated as a lightweight classifier that estimates task complexity.

Abstraction layers reduce switching costs. Libraries like LiteLLM and open-source model gateways normalize the API differences between Claude, Gemini, and other providers into a single interface. This lets teams swap models with a configuration change rather than a code rewrite. If you’re starting a new project, build behind an abstraction from day one.

Fallback chains improve reliability. Production AI features need uptime guarantees that no single provider can deliver. The standard pattern: try the primary model (e.g., Claude Sonnet), if it fails or times out, fall back to the secondary (e.g., Gemini Pro), if that fails, fall back to a cached response or graceful degradation. This requires both providers to be integrated but only one needs to succeed per request.

Gemini Flash is the cost optimization lever. For teams running millions of requests per month, Gemini Flash at $0.10/M input tokens is the cheapest path to serving simple workloads. Teams often start with Claude Sonnet for everything during prototyping, then migrate simple tasks to Gemini Flash as they optimize costs for production scale.

Evaluation is continuous. Both Anthropic and Google release model updates regularly. A model that wins today may not win in six months. Teams that invest in automated evaluation pipelines can re-benchmark on every model release and shift routing accordingly. See our guide on LLM evaluation for how to build this.

For a broader view of where Claude and Gemini fit in the AI platform landscape — including AWS Bedrock, Google Vertex AI, and Azure — see Cloud AI Platforms.

Summary and Key Takeaways

Claude and Gemini serve different workloads — the production pattern is routing tasks to each provider’s strength rather than picking one for everything.

Claude excels at reasoning, coding, and instruction following — 5-7% higher accuracy on complex tasks compared to Gemini
Gemini excels at multimodal and large-context tasks — native video/audio support and a 2M-token context window that Claude cannot match
Gemini is cheaper, especially at the budget tier — Flash at $0.10/M input tokens is 8x cheaper than Haiku at $0.80/M
Claude is more predictable with complex prompts — system prompt adherence and tool-calling reliability are measurably stronger
Use both — implement a model router that sends reasoning tasks to Claude and multimodal/bulk tasks to Gemini
Benchmark on your data — aggregate benchmarks don’t predict your specific task performance. Test 100+ real examples with both providers
Build behind an abstraction layer — normalize the API differences so you can swap providers with a config change, not a rewrite
Evaluate continuously — both providers release model updates frequently. Automated eval pipelines keep your routing optimal

Claude Sonnet vs Haiku — Deep dive into Claude model tiers
Claude vs ChatGPT — Anthropic vs OpenAI model comparison
GPT vs Gemini — The other major model comparison
Cloud AI Platforms — Where these models are deployed in production
LLM Evaluation — How to benchmark models on your specific tasks
Prompt Engineering — Optimizing prompts for Claude’s and Gemini’s different strengths
Fine-Tuning vs RAG — When to customize models vs retrieve context at inference time

Frequently Asked Questions

Is Claude better than Gemini?

It depends on the task. Claude (Anthropic) excels at reasoning, coding, and instruction following — it consistently produces more structured, reliable outputs for complex prompts. Gemini (Google) excels at multimodal tasks, has a larger context window (up to 2M tokens vs 200K), and integrates deeply with Google Cloud. For coding and analysis, Claude typically wins. For multimodal and large-context tasks, Gemini has the edge.

What is the difference between Claude and Gemini?

Claude is built by Anthropic and focuses on safety, reasoning, and code generation. Its model family includes Opus (most capable), Sonnet (balanced), and Haiku (fast/cheap). Gemini is built by Google and focuses on multimodal understanding, large context windows, and Google ecosystem integration. Its family includes Ultra (most capable), Pro (balanced), and Flash (fast/cheap).

Which is cheaper, Claude or Gemini?

Gemini is generally cheaper at the lower tiers. Gemini 2.0 Flash costs $0.10 per million input tokens vs Claude Haiku at $0.80 per million. At the mid tier, Gemini Pro and Claude Sonnet are more comparable. For high-volume simple tasks, Gemini Flash offers the lowest per-token cost among major providers.

Can I use both Claude and Gemini in the same application?

Yes, and many production systems do. A common pattern is model routing: use Claude for tasks requiring strong reasoning and code generation, Gemini for multimodal tasks and large-context processing. Both APIs follow similar request/response patterns, making it straightforward to implement a router that selects the best model per request.

Which is better for coding, Claude or Gemini?

Claude has a clear edge for coding tasks. Claude Sonnet consistently outperforms Gemini Pro on code generation benchmarks like SWE-Bench and HumanEval. Claude's instruction-following precision means it produces more reliable structured output, follows complex coding constraints, and generates fewer hallucinated APIs. For AI-assisted coding tools, Claude is the preferred model for most agent frameworks.

How do Claude and Gemini context windows compare?

Gemini 2.0 Pro supports up to 2 million tokens, while Claude Sonnet supports 200K tokens — a 10x difference. This means Gemini can process entire books, large codebases, or hundreds of documents in a single API call. Claude's 200K context is still large enough for most RAG pipelines and document analysis, but tasks requiring over 200K tokens of input favor Gemini.

How does structured output differ between Claude and Gemini?

Claude excels at following complex output format instructions — it reliably produces valid JSON, XML, or markdown when instructed. Gemini 2.0 also supports structured output with JSON mode and function calling, but Claude's instruction-following precision gives it an edge when output format compliance is critical. Both support tool use / function calling with JSON schema definitions.

Which is better for processing long documents, Claude or Gemini?

Gemini has the advantage for very long documents due to its 2M-token context window. However, Claude's 200K context with superior reasoning often produces better analysis of documents that fit within its window. For documents under 200K tokens, Claude's stronger reasoning makes it the better choice. For documents exceeding 200K tokens, Gemini is the only option among the two.

How do Claude and Gemini approach safety differently?

Claude (Anthropic) was built with Constitutional AI and emphasizes being helpful, harmless, and honest. It tends to be more cautious and will explicitly decline requests it considers potentially harmful. Gemini (Google) uses its own safety filters and may be more permissive in some areas while stricter in others. Both providers offer enterprise-grade safety configurations for production applications.

Which cloud platforms support Claude and Gemini?

Claude is available through the Anthropic API directly and through AWS Bedrock (for enterprise AWS deployments). Gemini is available through the Google AI Studio API and through Google Vertex AI (for enterprise GCP deployments). Claude is not available on Azure; Gemini is not available on AWS. Your existing cloud provider often determines which model is easiest to deploy.

Last updated: February 2026 | Claude Sonnet 4 / Gemini 2.0 Pro