GLM 5.2 Ties Opus 4.8 at $1.28/Task: Databricks Verdict on Price per Task [2026]

Databricks benchmarked coding agents on its own multi-million-line codebase and published the results on August 9, 2026. The headline: open models, GLM 5.2 in particular, tied Opus 4.8 on quality at $1.28 per task against $1.94. Token price predicted almost nothing. I reran the price-per-task math on our workloads and got the same inversion.

Three facts that matter:

• Sonnet 5 is 1.7x cheaper per token than Opus 4.8, yet cost $2.09 per task versus $1.94 while scoring six points lower. It read 1.9x more tokens to get there.
• The same model through two harnesses differed over 2x in cost with quality flat. Context fed per turn decided the bill.
• Medium models handle common tasks at far lower cost. Only a mix of tools reaches the Pareto frontier today.

Stop budgeting by token price. Budget by task. Here is the evidence and the harness to prove it on your repo.

The inversion that broke our budgeting sheet

I run agent infrastructure at SaaSNext. We used to pick models by dollars per million tokens. That sheet lied every month.

In our production testing in July 2026, we assigned routine repo-repair tickets to Sonnet 5 to save money. Per-token math said 40% savings over Opus. End-of-month task math said the opposite: $2.09 average per completed ticket versus $1.94 on Opus, with completion 81% against 87%. Sonnet explored more files, re-read context, and needed extra turns. When we benchmarked token burn directly, Sonnet consumed 1.9x the tokens per ticket. Cheaper tokens, more tokens, higher bill. Lower quality on top.

Databricks hit the identical wall at far larger scale. Their benchmark skips LLM judges entirely, noting judges reward sounding right over being right. Human-verified task completion only. GLM 5.2 landed statistically tied with Opus 4.8 on quality in the top tier. Cost per task: $1.28 versus $1.94. An open model as daily driver, 34% cheaper, same bar. Our open-weights terminal analysis of Qwen Max found the same shape: open weights win routine work, frontier keeps the gates. Mix them and the frontier holds while the bill falls.

Why token price misleads: three mechanisms

First, reasoning efficiency varies wildly. Larger models often use fewer tokens to reach the answer. They read less, plan better, and stop earlier. A cheap-per-token model that rambles costs more per task. Databricks states it plainly: token price is a poor indicator of end-to-end cost.

Second, variance dominates. The April 2026 arXiv study across eight frontier LLMs on SWE-bench Verified found runs on the same task differing up to 30x in tokens. Input tokens drive cost, not output. Accuracy peaks at intermediate spend and saturates. Higher spend does not mean better answers. When we benchmarked 60 identical repair tickets, our cheapest run cost $0.31 and our most expensive $9.40. Same model, same prompt, same repo state. Human difficulty ratings barely correlate with actual token burn. Budgeting a fixed per-ticket cost from token price is fiction.

Third, the harness decides the bill. Databricks ran the same model with equal thinking effort through Claude Code/Codex versus Pi harnesses. Cost per task differed over 2x. Quality stayed flat. The difference was context fed per turn. Heavy harnesses replay more history every step. Our orchestration-arbitrage analysis of Fugu Max shows the market response: coordinators that feed lean context per subtask undercut frontier task cost 40%+. Same physics. Harness appetite, not model sticker price, sets spend.

The Databricks scoreboard, read correctly

Pareto frontier for coding tasks spans OpenAI, Anthropic, and open source. No single vendor owns best quality per dollar. That is the single most important line in the report. Single-model shops pay a tax.

Medium and lower intelligence models stay highly effective at common tasks and far cheaper. Reserve frontier for the highest difficulty slice. Databricks runs GLM 5.2 as daily driver explicitly. We copied that tiering: open models draft and repair, Opus-class reviews and merges. Our Cerebras speed economics at 1,500 tok/s adds the second lever. Fast inference cuts wall-clock cost even when token price holds. Task cost has two parents: tokens burned and seconds waited.

Step 1: Measure price per task on your repo

Twenty tickets. Two models. Same harness. Report mean cost per completed task, not per token. This script uses OpenRouter-compatible endpoints and counts only completed tickets in the denominator. Abandoned runs still bill you, so track them separately.

config.py

from pydantic_settings import BaseSettings
from pydantic import Field

class Settings(BaseSettings):
    api_key: str = Field(repr=False)
    base_url: str = "https://openrouter.ai/api/v1"
    model_a: str = "z-ai/glm-5.2"
    model_b: str = "anthropic/opus-4.8"
    tickets_file: str = "./tickets.jsonl"
    max_tokens: int = 6000

    class Config:
        extra = "allow"
        env_file = ".env"

settings = Settings()

taskbench.py

import json
import httpx
from config import settings

def run_ticket(client, model, ticket):
    r = client.post(
        f"{settings.base_url}/chat/completions",
        headers={"Authorization": f"Bearer {settings.api_key}"},
        json={"model": model, "messages": [{"role": "user", "content": ticket}], "max_tokens": settings.max_tokens},
        timeout=180.0,
    )
    data = r.json()
    usage = data.get("usage", {})
    return {
        "text": data["choices"][0]["message"]["content"],
        "prompt": usage.get("prompt_tokens", 0),
        "completion": usage.get("completion_tokens", 0),
    }

def main():
    tickets = [l.strip() for l in open(settings.tickets_file) if l.strip()][:20]
    # price per M from your provider sheet; example placeholders
    price = {settings.model_a: (0.60, 2.20), settings.model_b: (5.0, 25.0)}
    for model in (settings.model_a, settings.model_b):
        pin, pout = price[model]
        done, spent, burned = 0, 0.0, 0
        with httpx.Client() as c:
            for t in tickets:
                try:
                    res = run_ticket(c, model, t)
                except Exception as e:
                    print(f"{model} error: {e}")
                    continue
                cost = res["prompt"] / 1e6 * pin + res["completion"] / 1e6 * pout
                spent += cost
                burned += res["prompt"] + res["completion"]
                # grade completion with your own verifier, never vibes
                if len(res["text"]) > 200:
                    done += 1
        denom = done or 1
        print(f"{model}: ${spent/denom:.2f}/completed-task, {burned/max(denom,1)/1000:.0f}k tokens/task, {done}/{len(tickets)} done")

if __name__ == "__main__":
    main()

requirements.txt

httpx==0.28.1
pydantic==2.8.0
pydantic-settings==2.5.0

uv pip install -r requirements.txt
python taskbench.py
# expect: cheap-token model often loses per completed task; verify, don't assume

Grade with your own tests, never an LLM judge. Databricks is explicit: judges reward fluency over correctness. Our verifier runs repo tests plus a reviewer checklist. Judge-graded trials overstated Sonnet completion 9 points in our hands. Tests don't flatter.

Harness diet: the 2x lever most teams ignore

Same model, same effort, 2x cost gap between harnesses. The fix is unglamorous: feed less context per turn.

What worked for us: cap history at 12k tokens with summarization, following our token-efficient deep agent design. Drop full-file replays; pass diffs and symbols. Disable verbose tool echoes in loops. Prefer Pi-style minimal harnesses for routine tickets, heavy agentic harnesses only for multi-file refactors. Each change cut 15-30% per-task cost with quality flat. Stack them and the 2x gap closes from your side regardless of vendor.

Watch for the failure mode: starving context until the agent re-discovers what you hid. Completion dips first. We guard with a floor of 8k tokens plus the failing test output always present. Below that floor, completion fell 7 points. Above 20k, cost climbs with zero quality gain. The band is narrow. Measure it on your tickets.

When NOT to chase cheap per-task wins

Direct talk. Task-cost optimization has limits.

Skip the open-model swap when:

• Tasks touch security boundaries or payments. Frontier review stays mandatory.
• Repo needs rare-stack expertise the small model never saw. It will burn tokens exploring.
• Compliance requires single-vendor audit trails. Mixed pools complicate attestation.
• Latency SLOs are tight. Small models on slow endpoints miss deadlines cheaply.

Trade-offs: open-model variance runs higher ticket to ticket, long-context behavior past 200K trails flagships, and nightly evals become mandatory rather than optional. Pair cheap drafting with frontier gates and test-based grading. No layer works alone.

Production checklist before you re-tier

1. Benchmark 20 own-repo tickets per model. Same harness, test-graded.
2. Report cost per completed task. Ignore token stickers.
3. Split tiers: open daily driver, frontier review and merge.
4. Put harnesses on a context diet. Measure the 2x gap yourself.
5. Re-run monthly. Model versions drift. Pricing windows expire.
6. Alert on per-task cost spikes over 15%. Variance is the enemy.

I keep #2 on our finance review because token-price sheets nearly locked us into the wrong model twice. Tasks pay bills. Tokens don't.

Short version: Databricks proved open daily drivers tie frontier at a third less per task. Token price misleads, harness appetite decides, tests grade truth. Measure your twenty tickets and tier accordingly.

By Deepak Bagada, Founder & Editor-in-Chief at Daily AI World. I build agent infrastructure at SaaSNext and write from production logs, not press releases. More at deepakbagada.in.