AI Model Price-to-Performance Guide

Introduction: Why Price-to-Performance Matters More Than Raw Capability

Every week a new model claims the top spot on a leaderboard. Every month prices drop 30–50%. The model that was "best" in January is overpriced by March. Chasing raw benchmarks is a losing game — the only metric that compounds is value per completed task.

This guide exists because the industry publishes capability scores and price lists separately. You get MMLU-Pro here, dollars-per-million-tokens there, and context windows somewhere else. Making a decision means stitching them together yourself, every time. We do that stitching once a week so you don't have to.

How to Read This Guide

Price Tiers (by input cost per 1M tokens)

Key Columns Explained

• Input $/M — Cost per 1 million input tokens (prompt + context)
• Output $/M — Cost per 1 million output tokens (completion)
• Cache Read $/M — Discounted rate when re-reading cached context (critical for agent loops)
• Context — Maximum context window in tokens
• Intelligence Index — Artificial Analysis composite (0–100, higher = more capable)
• Coding Index — Artificial Analysis coding-specific score
• Agentic Index — Artificial Analysis tool-use / multi-step score

Hidden Costs to Watch

• Output token inflation — Reasoning models (o1, o3, Fable 5) generate 3–10× more output tokens for the same answer
• Context bloat — Agent loops re-read context every turn; cache hits save 50–90% on input
• Rate limits — Free tiers often cap at 20–50 req/min; not viable for production
• Batch discounts — 50% off for async batch jobs (OpenAI, Anthropic, Google)
• Tokenizer drift — Newer tokenisers (Claude 4.7+) produce ~30% more tokens for the same text

The Model Tier List

Data pulled from OpenRouter API on 13 Aug 2026. 409 models total. Router/meta-models excluded from tier counts below.

Free Tier — 18 Models

Zero cost via OpenRouter's free tier. Strict rate limits (typically 20 req/min). No SLA. Use for prototyping, evals, and non-production workloads.

Budget Tier — ~150 Models (Input < $1/M)

Production-viable for high-volume, verifiable tasks. Many offer cache reads at 10–50% of base price.

Mid-Range Tier — ~100 Models (Input $1–5/M)

The sweet spot for most production agent loops. Strong capability, reasonable cost, good cache pricing.

Premium Tier — ~30 Models (Input $5–15/M)

Specialised for hard reasoning, agentic coding, and long-horizon tasks. Use as escalation, not default.

Frontier Tier — ~15 Models (Input > $15/M)

Escalation only. If you are here by default, you are overpaying. Route specific measured failures here.

Best Value by Use Case

Best for Coding / Development

Best for Reasoning & Math

Best for Long-Context Analysis (100K+ tokens)

Best for Chatbot / Customer Service

Best for Content Generation

Best for Agentic Workflows (Tool Use, Multi-Step)

Best for Multimodal (Vision + Text)

The Free Models Worth Using — Detailed Breakdown

All 18 free models on OpenRouter (as of 13 Aug 2026), with specific guidance on when each is the right choice.

Tier 1: Production-Capable Free Models

Tier 2: Specialised Free Models

Tier 3: Meta-Models & Safety

Hidden Costs Deep Dive

1. Context Caching — The Agent Loop Multiplier

In a typical agent loop, the same system prompt, tool definitions, and conversation history are re-sent every turn. Without caching, a 10-turn loop with 20K context = 200K input tokens billed at full price. With caching, only the first turn pays full price; subsequent turns pay the cache-read rate (typically 5–20% of base).

Design implication: Put stable content (system prompt, tools, RAG context) first. Volatile content (user messages) last. This maximises cache hits.

2. Output Token Inflation — Reasoning Models

Models with always-on thinking (Claude Fable 5, Opus 5, O1, O3) generate 3–10× more output tokens for the same visible answer. A 500-token answer may cost 5,000 output tokens. At $50/M output (Fable 5), that 500-token answer costs $0.25, not $0.025.

3. Rate Limits — Free vs Paid

Free tiers: 20–50 req/min, daily caps. Paid tiers: 1,000–10,000+ req/min. If your agent loop needs parallel execution or burst capacity, free tier will throttle you.

4. Batch Discounts — 50% Off for Async Work

OpenAI, Anthropic, and Google all offer 50% off for batch/async processing (24–48hr turnaround). Use for: evals, bulk extraction, offline report generation, nightly processing. Not for user-facing latency.

5. Tokenizer Drift — Newer Models Cost More Per Character

Claude 4.7+ tokenizer produces ~30% more tokens for the same English text vs 4.6 and earlier. GPT-4.1 tokenizer is similar. Budget 30% more input tokens when migrating to newer model generations.

How to Test Models for Your Use Case

Do not trust benchmarks. Do not trust this guide. Test on your data, your prompts, your success criteria.

Minimum Viable Evaluation (40 Cases, 1 Hour)

1. Collect 40 real cases from your production logs. Weight toward failures — the cases that broke your current model.
2. Define pass/fail per case. Binary is fine: "Did the agent complete the task correctly?"
3. Run on current model. Record: pass rate, total input tokens, total output tokens, wall-clock time, total cost.
4. Run on candidate model(s). Same 40 cases, same prompts, same tools.
5. Compare cost per passing case. Not cost per token. Not pass rate alone. Cost per pass = total cost / passing cases.

What to Measure

• Pass rate — Binary success on your task definition
• Turns to completion — Agent loop iterations (directly drives cost)
• Total tokens (in + out) — Actual bill driver
• Wall-clock latency — User experience
• Failure modes — Categorise: tool error, hallucination, reasoning error, timeout

Automation: The Weekly Eval Habit

Add this to your CI/CD. Every Monday, run your 40-case eval on the current default model + 2 candidates. If a candidate beats the default on cost-per-pass for two consecutive weeks, promote it. This guide's weekly update exists to give you the candidate shortlist.

Weekly Update Log

This section is updated every Monday with the automated pipeline. Manual annotations by DaedalusResearch.

Week of 13 Aug 2026 — Initial Publication

• Data refresh: Pulled 409 models from OpenRouter API
• New free models: Nemotron 3.5 Lightning, Gemma 4 31B/26B, GPT-OSS 20B/120B, Laguna S/XS 2.1, Nemotron Nano VL variants
• Price drops: GPT-5 Nano at $0.05/M (batch $0.025), Gemini 2.5 Flash-Lite at $0.10/M, DeepSeek V4 Flash at $0.14/M
• New premium models: GPT-5.6 Luna/Terra/Sol families, Claude Opus 5 / Fable 5, Qwen 3.8 series
• Notable: 18 free models now available (up from ~12 in July). Budget tier deepens significantly.
• Research note: DeepSeek V4 Flash ($0.14/M) emerges as the standout budget reasoning model — 1M context, cache at $0.028/M, strong coding.

Week of 6 Aug 2026

• Price drops: GPT-4.1 Nano batch at $0.05/M, Mistral Nemo at $0.019/M
• New models: Qwen 3.7 Flash/Plus, Nemotron 3 Ultra free tier
• Research note: Mistral Nemo ($0.019/M) is the new budget floor for general-purpose — but 131K context limits long-document work.

Week of 30 Jul 2026

• Major release: GPT-5 family (Nano/Mini/Pro) with batch pricing
• Anthropic: Sonnet 5 / Opus 5 / Fable 5 / Haiku 4.5 launch
• Research note: Fable 5's always-on thinking changes the cost calculus — effective output cost 5–10× listed rate. Route selectively.

Week of 23 Jul 2026

• Google: Gemini 2.5 Pro/Flash with 1M context and aggressive cache pricing ($0.01–0.125/M cache reads)
• Research note: Gemini 2.5 Flash-Lite at $0.10/M input + $0.01/M cache read = best value for long-context RAG.

Week of 16 Jul 2026

• DeepSeek: V4 Pro/Flash launch — $0.14/M Flash is a budget reasoning breakthrough
• Qwen: 3.5/3.6 series with MoE efficiency

Automation & Maintenance

This guide is regenerated weekly via an automated pipeline:

1. Data Collection (Sunday 02:00 UTC): Python script fetches OpenRouter /api/v1/models, extracts pricing, context, cache rates. Stores JSON snapshot in versioned history.
2. Diff Detection: Compares against previous week — flags new models, price changes >10%, removed models, context changes.
3. Enrichment: DaedalusResearch adds Artificial Analysis benchmark scores (intelligence, coding, agentic indices) where available.
4. Draft Generation: Script rebuilds tier tables, use-case recommendations, and update log entry.
5. Editorial Review (Monday 09:00 BST): DaedalusContent reviews diff, adds qualitative annotations, verifies no contradictory positioning with DaedalusDesign service tiers.
6. Publish: Updated HTML deployed to fullauto.online via build pipeline. RSS/feed updated.

Data Collection Script

/srv/samba/workspace/Projects/Daedalus Design/Development/scripts/fetch-openrouter-pricing.py

#!/usr/bin/env python3
"""
Fetch OpenRouter model pricing and metadata.
Run weekly via cron/N8N. Outputs JSON snapshot to data/pricing/YYYY-MM-DD.json
"""
import json
import requests
import pathlib
from datetime import datetime

OUT_DIR = pathlib.Path(__file__).parent.parent.parent / "data" / "pricing"
OUT_DIR.mkdir(parents=True, exist_ok=True)

def fetch():
    resp = requests.get("https://openrouter.ai/api/v1/models", timeout=30)
    resp.raise_for_status()
    data = resp.json()

    # Normalise
    models = []
    for m in data.get("data", []):
        pricing = m.get("pricing", {})
        models.append({
            "id": m["id"],
            "name": m["name"],
            "context": m.get("context_length"),
            "input_per_m": float(pricing.get("prompt", 0)) * 1_000_000,
            "output_per_m": float(pricing.get("completion", 0)) * 1_000_000,
            "cache_read_per_m": float(pricing.get("input_cache_read", 0)) * 1_000_000 if pricing.get("input_cache_read") else None,
            "modalities": m.get("architecture", {}).get("input_modalities", []),
            "reasoning": m.get("reasoning", {}),
            "created": m.get("created"),
        })

    snapshot = {
        "fetched_at": datetime.utcnow().isoformat() + "Z",
        "total_models": len(models),
        "models": models,
    }

    date_str = datetime.utcnow().strftime("%Y-%m-%d")
    (OUT_DIR / f"{date_str}.json").write_text(json.dumps(snapshot, indent=2))
    # Also write latest.json for easy access
    (OUT_DIR / "latest.json").write_text(json.dumps(snapshot, indent=2))
    print(f"Saved {len(models)} models to {OUT_DIR}/{date_str}.json")

if __name__ == "__main__":
    fetch()

N8N Workflow

Workflow ID: daedalus-price-guide-weekly on Nucleus N8N (videns.tail0d37a1.ts.net:5678).

• Trigger: Cron (Mondays 02:00 UTC)
• HTTP Request: GET OpenRouter models API
• Function: Diff against previous week (stored in N8N workflow data)
• HTTP Request: POST to DaedalusContent review endpoint (internal)
• Wait for approval
• Execute: Python build script to regenerate guide HTML
• Deploy: SCP to fullauto.online webroot