Tag: ai-models

  • Grade the Flight Recorder, Not the Answer

    Grade the Flight Recorder, Not the Answer

    From the Tygart Media research desk — our own instrument, our own data, our own receipts. Part of the GLM Desk.

    Here is a failure you cannot see by reading answers. In one evaluation we scored, a major AI surface produced the longest answer of the five we compared — over 6,600 characters, company names, confident detail. Its execution record showed the whole answer was built on one sub-query and zero sources actually consulted. A second surface’s entire evidence base, beneath an equally confident answer, was a single maps link. Graded on the answer text, both look like research. Graded on the record of what they did, both are writing from memory with good posture.

    That gap — between the closing pitch and the work underneath it — is why this shop grades trajectories. This page is the method, published the way we publish our settings: steal it.

    The instrument

    Our citation-measurement rig records more than final answers. For every chat it stores the execution trajectory: the sub-queries the surface issued while building its answer (in the order it issued them), the sources it actually consulted, and the call record — how many calls, what status. We built a scorer over that record. It grades the execution, not the summary, on four checks:

    X1 — Retrieval happened. Sub-queries issued or sources consulted. If neither exists, the verdict is FROM-MEMORY, whatever the answer claims.

    X2 — Intent match. What share of the sub-queries actually carry the question’s subject and place terms — did the surface go looking for what was asked, or for something adjacent and easier? This check is scored only where the telemetry exists. Some providers expose no sub-query record at all; there, the honest mark is NOT-SCORED, never a fail.

    X3 — Evidence breadth. Distinct source hosts actually consulted: five or more is BROAD, two to four ADEQUATE, one THIN, zero NONE.

    X4 — Execution health. The run completed and made at least one call. A surface that returned no answer at all is EXCLUDED from the denominators — per our standing convention, a non-answer is not a miss, it’s an absence — and is never failed.

    The verdicts — SOUND, THIN, FROM-MEMORY, EXCLUDED — are then compared against the old outcome read (was the company cited in the answer?). Where the two reads disagree in kind, the scorer raises a DELTA flag. Those flagged runs are the ones worth a human’s eyes: the uncited-but-sound answers and, more dangerous, the cited-but-hollow ones.

    What it caught that answer-grading couldn’t

    The two cases above opened this piece. The census work caught the same failure family from the other side of the glass. In our 44-model census, one flagship model opened its run with twenty-two steps that were echoes — “fetching page one,” “starting fetch” — announcements of tool calls it never made, before it eventually fetched for real. From the final answer alone you would never know the first half of the run was theater. Two top-end models ran explicit “verify the embeds” steps while holding the raw page source — and still reported no embeds, because their checking step used the same blind fetch tool as their fetching step. A verifier that shares the original blind spot is not a verifier, and only the step record shows it.

    On the GLM seat itself, trajectory reads are how this desk’s other findings were earned: the low-dial failure mechanism (one lens per item, deliberation stopping before the writing did) is a recorder observation, not a score inference — and so is the good news, like a code run that wrote and ran its own test fixtures before delivering, unprompted.

    The honest limits

    Telemetry is partial, and the method says so on its face. In the evaluation store this scorer runs against, sub-query records exist for about a fifth of the chats — 22 of 110 at adoption. Where they don’t exist, X2 is not scored and the verdict rests on the checks that remain; a run is never failed for its provider’s silence. The dashboard record on the agent side has the same texture: reasoning text is fully visible on tool-using runs, but some pure-text runs show thought duration only, and one run’s reasoning would not expand at all. The recorder is excellent. It is not total. Any read from it should state its basis — ours do.

    The rule it produced

    One line, now standing doctrine in our shop since October 16, 2026: grade the execution steps, not the summary. Every model we seat gets its recorder read, not just its answer scored. Every evaluation we publish says which read it stands on — and on the evaluation where the two reads first disagreed, we switched the standing read to the trajectory score and said so in the record. If you run agents, or buy answers from surfaces that do, the closing pitch is the last place the truth lives. The flight recorder is the first.

    The method at work: the GLM limit map and the reasoning-dial test are both trajectory-graded records; the desk’s hub keeps the full shelf.

    The settings box

    Instrument: a trajectory scorer over our citation rig’s stored execution records — sub-queries (position-ordered), consulted source hosts, call counts and status — read-only against the evaluation database.

    Rubric: X1 retrieval happened · X2 fan-out intent match (scored only where telemetry exists) · X3 evidence breadth by distinct hosts · X4 execution health (no-answer surfaces EXCLUDED, never failed). Verdicts SOUND / THIN / FROM-MEMORY / EXCLUDED, plus a DELTA flag against the outcome read.

    Telemetry basis: sub-query records present for 22 of 110 stored chats at adoption; dashboard reasoning text complete for tool-using runs, duration-only on some pure-text runs.

    Adopted: October 16, 2026. The worked examples above are from that day’s evaluation and census records.

  • Cost Per Finished Task: The Number AI Pricing Pages Don’t Print

    Cost Per Finished Task: The Number AI Pricing Pages Don’t Print

    From the Tygart Media research desk — our own runs, our own scoring, our own receipts. Part of the GLM Desk.

    Every AI pricing page on the internet prints the same table: dollars per million tokens, in and out. It’s accurate and it’s useless, because nobody buys tokens. You buy finished tasks — a census completed, a draft delivered, an audit verified — and the cost of a finished task depends on how the model behaves while doing it: how much it re-reads, how often it retries, whether it plans before it fetches. Per-token tables hide all of that.

    We can print the other number because we meter every agent run we seat and keep the receipts. What follows is cost per finished task from our own fleet records — dated, scoped, and with the task shapes named, because a cost without a task shape is just another token table.

    The receipts: what finished GLM tasks actually cost us

    All runs below: the same seat (details in the settings box), production or scored-battery work, platform charges as recorded.

    Finished task Cost Time
    15-page census — 60 exact fields, scored 60/60 1.01¢ ~2 min
    Two-hop verification chain (page → embed → title), confirmed two independent ways 0.64¢ —
    Code task, exact-output scored, self-tested on 3 fixtures before delivering 0.50¢ —
    QC hunt — 9 planted defects, 9/9 found, zero false positives 0.56¢ 46 sec
    Whole-site embed inventory — 152 URLs scanned, every embed extracted 1.45¢ 2m05s
    Citation-opportunity analysis — 250 queries across 5 sites, clustered and ranked 4.03¢ 4m01s
    Eight-task limit battery (the full set above plus contradiction, data, injection, voice tasks) 3.6¢ total —

    The shape to notice: the most expensive finished task on this list — a 250-query, five-site analysis with a 21,600-character input — cost four cents. The entire 15-run study behind this desk’s limit map and dial test cost about six cents. At these numbers, the cost of testing a seat properly is a rounding error; the cost of not testing it is paid in wrong answers shipped.

    The same brief, 44 models: behavior is the price

    Cost per task is where model choice stops being abstract. In our 44-model census — one identical brief, exact-match scoring — the runs that scored a perfect 20/20 ranged from 0.83¢ to 86.3¢. A hundred-to-one spread for the same correct answers. The cheapest perfect run was this seat. Three early finishers make the point in miniature: three models, three perfect scores — 13¢ (31 seconds), 6¢ (58 seconds), and 30¢ (52 seconds) respectively.

    And per-token price doesn’t predict where a model lands in that spread, because behavior intervenes. The slowest perfect run in the census took four minutes: it fought through four visible tool failures and re-fetched pages three times before landing perfect. Stubbornness finished the task — and the meter ran the whole time. A model that plans its fetch before fetching (the recorder shows this seat doing exactly that: weighing the fetch method against the task’s exactness requirement, then executing once) costs less per finished task than a model with cheaper tokens and sloppy process. The token table can’t tell you which is which. The receipt can.

    What we don’t claim

    These are one shop’s charges, on one platform, on one date, for no-repository agent tasks of the shapes named above. Direct API usage prices by token — the maker’s official card for this model lists $0.15 per million input tokens and $0.50 per million output at the time of writing — and your tasks will meter differently than ours. Treat every figure here as a receipt, not a rate card: evidence of what a finished task cost when a specific seat did specific work on a specific day. That’s still more than the token tables give you, which is the point of publishing them.

    We update this page when the desk’s records add a materially different task shape — or when the watch on the maker’s catalog fires and the pricing ground moves. If nothing changes, nothing is posted; that’s the desk’s standing promise.

    The settings box

    Seat: GLM 5.3 Flash, reasoning pinned to max, Cursor cloud agents, no code repository — except the census rows, which are each model’s own catalog seat under one identical brief.

    Cost basis: the platform’s own per-run charges, as recorded at run time. Task costs are for the finished, accepted deliverable — failed and retried runs in the census are noted in the census piece itself.

    Token reference: maker’s official pricing card (docs.z.ai), read October 16, 2026: $0.15 in / $0.50 out per 1M tokens for this model.

    Date: runs executed October 16, 2026. Study total: the 15 scored runs behind this desk cost ≈6¢ combined.