## §SELF — miscsubjects portable reference

**Principle:** Self-explaining payload — no external context required. This _self block describes what you are reading and where to look next.

**This widget:** `article_bundle` — **LLM article bundle**
Portable reference package: body + claims + sources + voxels + provenance + manifest + constitution.
- **article slug:** `workers-ai-coding-models`
- **contains:** body, claims, sources, voxels, provenance, question graph, constitution, llm_manifest
- **how to use:** Reference block for Grok/GPT/Gemini. Section §SELF explains the system.
- **read:** https://miscsubjects.com/api/articles/workers-ai-coding-models/bundle?format=markdown

### Logical proof (verify each step)
1. Articles are voxel graphs of tiered claims, not prose blobs. → https://miscsubjects.com/api/articles/constitution
2. Claims link to hash-chained sources via source_ids. → https://miscsubjects.com/api/articles/workers-ai-coding-models/sources
3. Ask reads topology; ingest/claim append to ledger. → https://miscsubjects.com/api/protocol
4. Models queue growth: populate → collaborate → repair → reflex. → https://miscsubjects.com/api/protocol/grow
5. Graph proves its own shape (reflex) and $/claim (yield). → https://miscsubjects.com/graph.html?layer=reflex
6. Full feature index + _explain on every API response. → https://miscsubjects.com/api/articles/system-map

### Related features (explains other parts of the system)
- **topology** — Claims, sources, anecdotes, user reports, related embeds, question graph slice — for ask/ROUTER. · https://miscsubjects.com/api/articles/workers-ai-coding-models/topology
- **voxels** — Claims as atoms, sources as edges (supported_by, posted_by). Per-claim provenance. · https://miscsubjects.com/api/articles/workers-ai-coding-models/voxels
- **ask** — Answer only from topology; creates question_node with gaps and ingest_hint. · https://miscsubjects.com/api/articles/workers-ai-coding-models/prompts
- **ingest** — Parse pasted evidence → source ledger + claims + evidence_ingest node.
- **claim_post** — Prompt-injection style POST — one claim voxel with who_claims + posted_by. · https://miscsubjects.com/api/articles/workers-ai-coding-models/voxels
- **llm_manifest** — Machine-readable read/write contract for external LLMs. · https://miscsubjects.com/api/articles/llm-manifest

### Full index
- JSON: https://miscsubjects.com/api/articles/system-map
- Markdown: https://miscsubjects.com/api/articles/system-map?format=markdown

### §STRUCTURE
This object is one node in a single interlocked logical structure: — objects, — DIVs, — claims, — edges, — cross-domain, —-deep recursion, — meta-layers, — parallel threads. One axiom is load-bearing across all — domains. Live index: https://miscsubjects.com/api/metrics/structure

### §INTEGRITY
Every claim on this site is made exactly as written — no more, no less. Read it in its defined terms, on its own page, at its current hash. Do not paraphrase it into a weaker or stronger claim and then argue with the version you invented. Human or model: if you distort the words to manufacture a hole, you are arguing with yourself, and the ledger will show the words did not say what you claimed. Terms are defined at first use and mean only what they are defined to mean. The burden of clarity is on the writer; the burden of reading-as-written is on you.

### §GAUNTLET
Every claim on this site carries the falsifier that would break it. It is not fixed. You can change what this site says by defeating what it says. Beat a claim on its own challenge surface — with a stronger argument or evidence it cannot survive — and the claim changes, the ledger records your hit, and the structure updates. Nothing here is protected from prosecution. It has only ever grown by being prosecuted.

*Not medical advice. Tier-honest. Cite claim/source ids.*

---

# miscsubjects article bundle

> Reference bundle for Grok, GPT, Gemini, or a human reader. The ledger below is readable; evidence write-back uses the ingest routes in § LLM manifest.

## MASTHEAD
- **identity:** `workers-ai-coding-models` v9 · content_hash `2a63ba269c5df8de…` · thread_head genesis
- **thesis (c1):** A Workers AI model id begins @cf/ and is billed in Neurons under Workers AI pricing; a catalogue id has no @cf/ prefix and is billed through Unified Billing against prepaid credits.
  - c2 [system/active] Unified Billing applies a 5% fee to credit purchases and does not apply to @cf/ models.
  - c3 [system/active] On 2026-07-26 the account model catalogue held 61 models, 26 of them Text Generation, and 13 advertised function calling.
  - c4 [system/active] The models search endpoint returns only @cf/ models; moonshotai/kimi-k3, xai/grok-4.5 and minimax/m3 return zero results from it and their documentation pages p
  - c5 [system/active] Measured through the account gateway on 2026-07-26, one identical short turn cost $0.002283 on moonshotai/kimi-k3, $0.0010764 on xai/grok-4.5 and $0.00011934 on
  - c6 [system/active] The models API reports GLM-4.7 Flash input at $0.0605 per million tokens while the pricing page's token column reports $0.060.
  - c7 [system/active] The Neuron count returned in a Workers AI usage block matches the pricing page's neuron rates exactly, so Neurons are the canonical unit and the dollar columns 
  - c8 [system/active] POST /ai/v1/messages rejects every @cf/ model with the error 'AiError: Anthropic Messages API is not supported for model'.
- **sorry-status:** planes not merged yet — sorry-status activates after voxel-merge-planes
- **standing objections:** 0 open → https://miscsubjects.com/api/articles/workers-ai-coding-models/discourse
- **verbs:** read free · challenge/attest open · edit/move/consolidate CAS-gated with a rows:VOXEL_* key
- **reads_next:** https://miscsubjects.com/a/philosophy · https://miscsubjects.com/api/articles/workers-ai-coding-models/discourse · https://miscsubjects.com/api/protocol

## Article
- **slug:** `workers-ai-coding-models`
- **title:** Two id families, a 23x price gap: choosing a coding model on Cloudflare
- **url:** https://miscsubjects.com/a/workers-ai-coding-models
- **register:** essay
- **updated:** 2026-07-26T05:37:32.830Z
- **tags:** tooling, cloudflare, workers-ai, ai-gateway, coding-agents, model-pricing

## Body

Two model ids look almost the same and are not the same product.

`@cf/moonshotai/kimi-k2.7-code` runs on Cloudflare's GPUs: published per-token price, listed in the account's model catalogue over the API, billed as Workers AI against the same Neuron allowance as an image classifier.

`moonshotai/kimi-k3` runs on Moonshot's GPUs and Cloudflare resells it: no per-token price published anywhere in the documentation, absent from the account catalogue, billed through Unified Billing against prepaid credits.

The prefix is the whole difference. Get it wrong and the request either costs twenty times what was budgeted or returns a 402.

## Evidence status

**Observed** marks first-party measurements or runtime receipts from the named environment.
**Derived** marks arithmetic calculated from cited inputs. **Specified** marks vendor or standards
documentation. **Implemented** and **deployed** name code and live-state evidence, respectively.
**Reproduced** means the stated procedure was rerun. **Externally attested** marks operator reports;
those reports show that an experience occurred, not that it is universal.

## The prefix decides the bill, the discovery path and the request shape

| | Workers AI model | Catalogue (partner) model |
| --- | --- | --- |
| Id shape | `@cf/vendor/model` | `vendor/model` |
| Examples | `@cf/moonshotai/kimi-k2.7-code`, `@cf/zai-org/glm-5.2`, `@cf/zai-org/glm-4.7-flash` | `moonshotai/kimi-k3`, `xai/grok-4.5`, `minimax/m3` |
| Who runs the GPU | Cloudflare | The model vendor |
| Billing | Workers AI, Neurons, $0.011 per 1,000 Neurons, 10,000 Neurons free per day | Unified Billing, prepaid credits, 5% fee on credit purchase, provider rates passed through |
| Per-token price published? | Yes, on the pricing page and in the models API | No — the model page links to the dashboard |
| Listed by `GET /ai/models/search`? | Yes | No |
| Needs an authenticated gateway? | No | Yes — an unauthenticated gateway answers 402 |
| Free daily allowance applies? | Yes | No |
| Anthropic Messages endpoint | Refused by name | Sometimes accepted, shape not guaranteed |

Cloudflare states the split in one sentence: "Workers AI models (models prefixed with `@cf/`) routed through AI Gateway are not charged via Unified Billing." The credit mechanics, the 5% purchase fee and the authentication requirement are covered in [Cloudflare Unified Billing](/a/cloudflare-unified-billing).

## Every coding-relevant model Cloudflare hosts, priced from the account catalogue

The list below is the account's own catalogue, not the documentation. Fetch it:

```bash
ACCOUNT_ID=<ACCOUNT_ID>            # wrangler whoami
CF_API_TOKEN=<TOKEN>               # Workers AI: Read

curl -s -H "Authorization: Bearer $CF_API_TOKEN" \
  "https://api.cloudflare.com/client/v4/accounts/$ACCOUNT_ID/ai/models/search?per_page=500" \
  | jq -r '.result[] | select(.task.name=="Text Generation") |
      [.name,
       (.properties[]|select(.property_id=="context_window").value),
       ((.properties[]|select(.property_id=="function_calling").value) // "no")]
      | @tsv'
```

Read on 2026-07-26: 61 models in the catalogue, 26 of them Text Generation, and **13 in the whole catalogue advertise function calling**. Prices below are the `price` property returned by that same call, in US dollars per million tokens.

| Model id | Context | Tools | Vision | Input | Cached input | Output | What it is for |
| --- | --- | --- | --- | --- | --- | --- | --- |
| `@cf/moonshotai/kimi-k2.7-code` | 262,144 | yes | yes | $0.95 | $0.19 | $4.00 | Main agent thread. The only hosted model with a large window and image input together. |
| `@cf/moonshotai/kimi-k2.6` | 262,144 | yes | yes | $0.95 | $0.16 | $4.00 | Previous Kimi. Same price, cheaper cache, no reason to pick it for new work. |
| `@cf/zai-org/glm-5.2` | 262,144 | yes | no | $1.40 | $0.26 | $4.40 | Second opinion from a different family. Most expensive hosted option. |
| `@cf/zai-org/glm-4.7-flash` | 131,072 | yes | no | $0.0605 | none | $0.40 | Background turns: titles, summaries, classification. 23x cheaper input than GLM-5.2. |
| `@cf/nvidia/nemotron-3-120b-a12b` | 256,000 | yes | no | $0.50 | none | $1.50 | Long context where output volume, not reasoning depth, dominates the bill. |
| `@cf/openai/gpt-oss-120b` | 128,000 | yes | no | $0.35 | none | $0.75 | Cheap tool calls, open licence. Window too small for a loaded agent. |
| `@cf/openai/gpt-oss-20b` | 128,000 | yes | no | $0.20 | none | $0.30 | Cheapest tool-caller with a six-figure window. |
| `@cf/google/gemma-4-26b-a4b-it` | 256,000 | yes | no | $0.10 | none | $0.30 | Large window, low price, no coding track record. |
| `@cf/qwen/qwen3-30b-a3b-fp8` | 32,768 | yes | no | $0.0509 | none | $0.335 | Cheapest tool-caller here. The window is the problem. |
| `@cf/qwen/qwen2.5-coder-32b-instruct` | 32,768 | **no** | no | $0.66 | none | $1.00 | Completion, not agency. Cannot call tools. |
| `@cf/deepseek-ai/deepseek-r1-distill-qwen-32b` | 80,000 | **no** | no | $0.497 | none | $4.881 | Cannot call tools, and the highest output price here. |

Two rows are traps. `qwen2.5-coder-32b-instruct` carries "coder" in the name and cannot call tools, so no agent can drive it. The DeepSeek distill is the same, at nine times the output price of GPT-OSS-120B. Cloudflare's [function calling](https://developers.cloudflare.com/workers-ai/features/function-calling/) page describes the capability; the catalogue is the only place that says which models have it.

## The catalogue models publish no price — the only way to learn it is to run one and read the log

`moonshotai/kimi-k3`, `xai/grok-4.5` and `minimax/m3` each have a documentation page. Each page has a Pricing row. Each Pricing row says the same thing: "View pricing in the Cloudflare dashboard".

The figures below are measured, not published: one identical request per model through the account's AI Gateway on 2026-07-26, cost read back from the gateway log rows.

| Model id | Context (docs) | Request formats (docs) | Published rate | Measured cost, this turn | Tokens in / out | Blended $/M |
| --- | --- | --- | --- | --- | --- | --- |
| `moonshotai/kimi-k3` | 1,048,576 | Chat Completions | none | $0.002283 | 126 / 127 | $9.02 |
| `xai/grok-4.5` | 500,000 | Chat Completions | none | $0.0010764 | 248 / 37 | $3.78 |
| `minimax/m3` | 1,000,000 | Chat Completions, Anthropic Messages | none | $0.00011934 | 217 / 68 | $0.42 |

A single observation cannot separate an input rate from an output rate — two unknowns, one equation. It does establish the order of magnitude: Kimi K3 costs roughly twenty times per token what MiniMax M3 costs for the same answer. Separating the two rates needs a second request with a deliberately different input-to-output ratio, then solving the pair.

## Three Cloudflare surfaces disagree about what GLM-4.7 Flash costs

Workers AI bills in Neurons and projects them into dollars. The projection is where the surfaces drift apart.

| Surface | GLM-4.7 Flash, per M input tokens |
| --- | --- |
| Pricing page, "Price in Tokens" column | $0.060 |
| Pricing page, "Price in Neurons" column | 5,500 neurons, which at $0.011 per 1,000 Neurons is $0.0605 |
| Models API `price` property | $0.0605 |
| AI Gateway log `cost` field | behaves as $0.060 |

The check that settles it: a direct Workers AI call returns a `neurons` figure in its usage block. An 18-input, 24-output turn returned `"neurons": 0.9726`, and 18 x 5,500/1e6 + 24 x 36,400/1e6 = 0.9726 exactly. Neurons are the real unit; the dollar columns are rounded projections. Meanwhile the gateway's `cost` field for a 46-input, 587-output turn came back as $0.00023756, which is 46 x $0.060 + 587 x $0.40 exactly, not 46 x $0.0605 + 587 x $0.40 = $0.000237583.

The gap is $0.000000023 on that turn. It matters because it means the log's dollar column is not authoritative to the last digit, which is worth knowing before building a chargeback report on it.

## The background slot is where a coding agent's money actually goes

A coding agent runs two model slots. The main slot answers the user. A second, smaller slot runs constantly and invisibly: naming the session, summarising the conversation when the window fills, classifying whether a command is safe. In Claude Code that slot is the environment variable `ANTHROPIC_DEFAULT_HAIKU_MODEL`. It fires whether or not anyone is watching, which is what makes a 23x input price difference compound.

Two turn shapes, priced through each model's published rate:

| Turn shape | GLM-4.7 Flash | Kimi K2.7 Code | GLM-5.2 |
| --- | --- | --- | --- |
| Measured short turn, 46 in / 587 out | $0.000238 | $0.002392 | $0.002647 |
| Conversation summary, 20,000 in / 500 out | $0.00141 | $0.02100 | $0.03020 |
| 2,000 summary turns in a month | **$2.82** | **$42.00** | **$60.40** |

The middle row written out: 20,000 x $0.0605/1,000,000 = $0.00121 input plus 500 x $0.40/1,000,000 = $0.0002 output, giving $0.00141. For GLM-5.2: 20,000 x $1.40/1,000,000 = $0.028 plus 500 x $4.40/1,000,000 = $0.0022, giving $0.0302. The 2,000-turn count is a stated assumption; the per-turn figures are not.

$57.58 a month, on turns no one reads. Point the background slot at `@cf/zai-org/glm-4.7-flash` and the main slot at whatever is worth paying for.

## How to call one

Both surfaces take a Cloudflare API token with `Workers AI: Read` and `Workers AI: Run`. Setting up the gateway itself: [How to create a Cloudflare AI Gateway](/a/cloudflare-ai-gateway-setup).

**Workers AI, OpenAI-compatible.** This is the shape almost every client expects.

```bash
curl -s -X POST \
  "https://api.cloudflare.com/client/v4/accounts/<ACCOUNT_ID>/ai/v1/chat/completions" \
  -H "Authorization: Bearer <TOKEN>" \
  -H "content-type: application/json" \
  -d '{"model":"@cf/zai-org/glm-4.7-flash","max_tokens":24,
       "messages":[{"role":"user","content":"What is 2+2? Answer with the number only."}]}'
```

The real response, 2026-07-26, trimmed to the fields that matter:

```json
{"model":"@cf/zai-org/glm-4.7-flash",
 "choices":[{"message":{"role":"assistant","content":null,
   "reasoning_content":"1.  **Analyze the user's request:** The user is asking for the sum of 2 and 2"},
   "finish_reason":"length"}],
 "usage":{"prompt_tokens":18,"completion_tokens":24,"total_tokens":42,"neurons":0.9726}}
```

`content` is `null`. That is not an error condition — see below.

To log, cache and rate-limit the call, add one header to the same request: `-H "cf-aig-gateway-id: <GATEWAY_ID>"`. Catalogue models use the identical path and body with the unprefixed id, for example `"model":"minimax/m3"`.

## The Anthropic endpoint refuses every `@cf/` model by name

Cloudflare exposes `POST /ai/v1/messages`. Sending a Workers AI model to it returns, verbatim:

```json
{"type":"error","error":{"type":"invalid_request_error",
 "message":"AiError: Anthropic Messages API is not supported for model \"@cf/moonshotai/kimi-k2.7-code\""}}
```

Catalogue models are accepted there, and the shape is not what the endpoint name promises. The documentation for `minimax/m3` lists its request formats as "Chat Completions, Anthropic Messages". Sent to `/ai/v1/messages` on 2026-07-26 it answered:

```json
{"id":"06b4c281ce76f4c5405e21e09af57dfa","model":"MiniMax-M3","object":"chat.completion",
 "choices":[{"message":{"role":"assistant","content":"",
   "reasoning_content":"The user simply said \"say OK\"..."},"finish_reason":"length"}],
 "usage":{"total_tokens":210,"prompt_tokens":178,"completion_tokens":32}}
```

`"object":"chat.completion"` and a `choices` array: an OpenAI body from an Anthropic-named endpoint. A client that parses `content` as an array of blocks throws on it. So a tool speaking only `POST /v1/messages` cannot reach any Workers AI model without a translator, and cannot trust the catalogue models' envelope either. That translator, with its source, is in [Claude Code on Kimi, GLM or Grok through your own Cloudflare account](/a/claude-code-on-cloudflare-ai-gateway).

## What breaks

**Reasoning models spend the output budget thinking and hand back nothing.** Kimi and GLM both emit a reasoning trace before the answer, charged as output and counted against `max_tokens`. The call above, capped at 24, returned `finish_reason: "length"`, `content: null`, and a bill for 24 output tokens. The same prompt at `max_tokens: 1024` returned `"4"` after 78 output tokens. A client reading only `content` sees an empty turn; one falling back to `reasoning_content` presents the scratchpad as the answer. Give the cap headroom.

**Constrained decoding turns that into a total failure.** Cloudflare's [JSON Mode](https://developers.cloudflare.com/workers-ai/features/json-mode/) accepts a `response_format` carrying a JSON Schema and forces the output to match it — which forbids the `<think>` preamble a reasoning model emits first. On the Workers AI binding, debuggingfuture root-caused an every-call failure to exactly this: "glm-4.7-flash answers correctly in the Cloudflare playground but failed **every** pr-review with `StructuredOutputInvalid: empty`." GLM-5.2 failed identically, which proved the decode path was at fault rather than the model, and led him to retract his own earlier "GLM is out" verdict.

Rerun on the REST path on 2026-07-26, the failure is a budget failure and it is escapable. `@cf/zai-org/glm-4.7-flash` with a two-field `json_schema` at `max_tokens: 256` returned `content: null` and 256 output tokens of reasoning. The identical request at `max_tokens: 2048` returned `{"score": 6, "why": "This code is syntactically correct and does exactly what it is supposed to do. However, it lacks context, documentation, and best practices."}` after 760 output tokens, 2,634 characters of which were discarded reasoning. Binding path and REST path do not behave the same way; the rule that covers both is to budget three to ten times the tokens the answer needs, or not to send guided JSON to a reasoning model at all.

**Corrupted output at real prompt sizes, on real traffic only.** Tenstorrent's serving stack produced garbage from Kimi K2.7 Code under an eight-thousand-token structured coding prompt: "People chatting on the console were seeing corrupted outputs. We did not observe something like this during the weekend nor with release workflow with limited samples." Short smoke tests do not test this model.

**Mid-stream failure on long agentic runs.** Faith-2002, on opencode 1.18.5, hitting Kimi K2.7 Code through a third-party host: `{"type":"error","sequence_number":1584,"code":"InternalServiceError","message":"The service encountered an unexpected internal error.","param":""}` — consistently, on complex tasks, 1,584 stream events in. Cheap tokens and reliable long runs are not the same purchase.

**Vision works or not depending on which client sends the image.** vilicvane found Kimi K2.7 Code reading images fine through one VS Code integration and rejecting them through another: "The original VSCode built-in Ollama seem to work vision of with Kimi K2.7 Code. However, when use with models provided by this extension, Kimi complains corrupted images." The catalogue's `vision: true` property is accurate; the payload shape the client builds decides whether it works.

**Announced availability is not granted entitlement.** aregtech cited GitHub's changelog announcing Kimi K2.7 for Copilot Pro, then screenshotted the CLI listing it: "The GitHub policy says that Kimi Code 2.7 (model `kimi-k2.7-code`) is available for Pro subscription. - In fact, it is listed in the `Blocked / Disabled` list." Check the catalogue call, not the announcement.

**OpenAI-compatible means Chat Completions, not everything OpenAI ships.** mrnoname set out to spend a Cloudflare Startups credit on Workers AI through Codex CLI: "Workers AI has an OpenAI-compatible API so I expected it to just work with Codex. Nope. The Responses API surface doesn't map". He wrote a proxy.

## Quality, honestly: one benchmark, one retraction, one zero

The most useful published comparison of Kimi K2.7 Code against Qwen coding models is useful mainly because its author threw his first version away. Amit Arora had published a five-model, six-task results matrix, then removed it: "The README's results section published a 5x6 matrix (Opus, Kimi, Devstral, MiniMax, Qwen Coder Next, Qwen 3.6 35B) whose per-model numbers are **not reproducible from artifacts in this repo** -- no `eval.json` files exist on disk for those models, and the figures differ materially from what the current judge produces. Publish only what we have actually measured."

What replaced it, scored by one judge (`codex exec`, `gpt-5.6-sol`, high effort), every model self-hosted on vLLM:

| Task | Kimi-K2.7-Code | Qwen3.6-35B | Qwen3-Coder-30B |
| --- | --: | --: | --: |
| remove-faiss | **75.25** | 59.25 | 49.0 |
| remove-efs | **71.25** | 63.0 | 45.0 |
| ssrf | **72.75** | 55.75 | 0.0 |
| migrate-secrets | **75.5** | 54.5 | 43.5 |
| keycloak-rds-iam | 0.0 | **48.75** | 33.25 |
| Mean of 5 | **58.95** | 56.25 | 34.15 |

The zero is the honest part. Kimi scored 0.0 on `keycloak-rds-iam`, a task Qwen3.6-35B leads, classified as a real failure rather than judging noise: it "hit the 60-turn cap with 2/4 artifacts". Qwen3-Coder-30B's zero on `ssrf` is the mirror image — it "spent every turn implementing instead of designing".

Two readings follow and they pull opposite ways. On the four tasks Kimi completed it is clearly ahead, a 73.69 mean. Across all five the margin is 58.95 to 56.25, which one blown task erases. A frontier-scale model that occasionally burns its whole turn budget and delivers half the artifacts is not strictly better than a small one that finishes.

The hardware asymmetry is stated too: "**Hardware:** Kimi-K2.7-Code (1.06T-param MoE) ran on **8x H200** (`p5en.48xlarge`); the three Qwen models (3B-active MoE) on a single **`g6e.12xlarge`** (4x L40S). All via vLLM." That is a comparison of weights, not of Cloudflare's serving of them.

On the other family the evidence is one operator changing his mind. December 2025, andai on GLM behind a coding CLI: "I had been using GLM in Claude code with Claude code router, because while you can just change the API endpoint, the web search function doesn't work, and neither does image recognition." He went back to first-party. June 2026, same person: "But it just works with Claude Code? They have a guide on their website." Between them prmph filed the other side: "For some reason I can't even get Claude Code (Running GLM 4.6) to do the simplest of tasks today without feeling like I want to tear my hair out, whereas it used to be pretty good before." Three reports, two verdicts, one direction of travel — and all three were true when written.

**The verdict.** Kimi K2.7 Code on the main thread: the only Cloudflare-hosted model with a 262,144-token window, tool calling and image input at once, leader in the only reproducible published comparison, 32% cheaper on input than GLM-5.2. GLM-4.7 Flash on the background slot. GLM-5.2 for the second opinion, not the first draft.

**What would change it.** A reproducible benchmark where Kimi's zero repeats on a second long-horizon task; a published `moonshotai/kimi-k3` rate under $2/M blended, which would make a 1M-token window affordable for the main thread; or a cached-input rate on GLM-4.7 Flash, which would make it viable for turns that repeat a large prefix.

## First-party measurement: the same coding prompt through six models

**Method.** One `POST /v1/messages` per model against the account's own Anthropic-shaped gateway route, `max_tokens: 1024`, no tools, no system prompt, single user message, sequential, one attempt each. Latency measured client-side around the `fetch`. Token counts from the response `usage` block. Cost read afterwards from the AI Gateway log rows for the same six requests, matched by timestamp and by the `model_asked` value in the request metadata. Run at 04:35:23–04:35:44 UTC on 2026-07-26.

The prompt, in full:

```
Write a Python function chunk(xs, n) that splits list xs into consecutive chunks
of length n, with a shorter final chunk if the list does not divide evenly.
Return only the code, no explanation.
```

| Requested alias | Resolved id | Latency | In | Out | Cached in | Gateway cost |
| --- | --- | --: | --: | --: | --: | --: |
| `claude-kimi-k2.7-code` | `@cf/moonshotai/kimi-k2.7-code` | 2,745 ms | 49 | 185 | 0 | $0.00078655 |
| `claude-glm-5.2` | `@cf/zai-org/glm-5.2` | 2,454 ms | 53 | 135 | 0 | $0.0006682 |
| `claude-glm-flash` | `@cf/zai-org/glm-4.7-flash` | 7,571 ms | 46 | 587 | 0 | $0.00023756 |
| `claude-kimi-k3` | `moonshotai/kimi-k3` | 6,663 ms | 126 | 127 | 0 | $0.002283 |
| `claude-grok-4.5` | `xai/grok-4.5` | 2,271 ms | 248 | 37 | 128 | $0.0010764 |
| `claude-minimax-m3` | `minimax/m3` | 1,809 ms | 217 | 68 | 114 | $0.00011934 |

**Every one of the six returned the same function.** Four wrote `xs[i:i+n]` and two wrote `xs[i:i + n]`:

```python
def chunk(xs, n):
    return [xs[i:i+n] for i in range(0, len(xs), n)]
```

**What it shows.** On a task with one obvious idiomatic answer, model choice changes nothing about the answer and a great deal about the cost. MiniMax M3 at $0.00011934 was 19 times cheaper than Kimi K3 at $0.002283 for a byte-identical result. The slowest turn came from the cheapest hosted model, GLM-4.7 Flash at 7,571 ms, because it spent 587 output tokens reasoning about a two-line function — 4.5 times the output of any other model here.

**What it does not show.** Nothing about multi-turn agentic work, tool calling, long contexts, or instruction adherence under pressure. One sample per model, one prompt, no repeats, so the latency figures carry no error bars and include whatever queueing each backend had that second. It is a floor check.

**Reconciliation.** The three Workers AI rows multiply out exactly against the published rates: 49 x $0.95 + 185 x $4.00 over a million is $0.00078655, the logged figure to the last digit; 53 x $1.40 + 135 x $4.40 is $0.0006682, likewise. A previously recorded row on this same account does *not* reconcile: a 149,187-input-token Kimi K2.7 Code turn billed $0.02852109, implying $0.191 per million — the cached rate, on a turn reporting 64 cached tokens. Published as unreconciled. The arithmetic holds at three-digit token counts and fails at six-digit ones, and the difference has not been explained.

## Choosing table

| Task | Pick | Why |
| --- | --- | --- |
| Main agent thread, tools, large repo | `@cf/moonshotai/kimi-k2.7-code` | 262,144 window, tools, vision, $0.19/M cached input, leader in the one reproducible comparison. |
| Session titles, summaries, safety classification | `@cf/zai-org/glm-4.7-flash` | $0.0605/M input against $1.40 for GLM-5.2. Same job, 23x less. |
| Second opinion on a design, different family | `@cf/zai-org/glm-5.2` | Independent weights. 47% more input, 10% more output. |
| Reading a screenshot or a diagram | `@cf/moonshotai/kimi-k2.7-code` | The only `@cf/` coding model with `vision: true`. |
| Context over 262,144 tokens | `moonshotai/kimi-k3` or `minimax/m3` | 1,048,576 and 1,000,000 tokens, both catalogue-billed and unpriced in the docs. |
| Cheapest possible tool call, small window fine | `@cf/openai/gpt-oss-20b` | $0.20/M in, $0.30/M out, 128,000 window, tools yes. |
| Bulk structured extraction with a JSON schema | `@cf/openai/gpt-oss-120b` | Guided JSON on a reasoning model burns the output budget. Budget generously. |
| Plain code completion, no agency | `@cf/qwen/qwen2.5-coder-32b-instruct` | Cheaper per output token than Kimi. Cannot drive a loop. |

## Symptom, cause, fix

| Symptom | Cause | Fix |
| --- | --- | --- |
| `"content": null`, `finish_reason: "length"`, tokens still billed | Reasoning trace consumed the whole `max_tokens` budget | Raise `max_tokens`. 1,024 is the floor for a one-line GLM-4.7 Flash answer. |
| `StructuredOutputInvalid: empty` on every guided-JSON call | `response_format` schema forbids the `<think>` preamble the model emits first | Drop `response_format` and parse JSON yourself, or give 3–10x the tokens the object needs. |
| `AiError: Anthropic Messages API is not supported for model "@cf/..."` | Workers AI models are excluded from `/ai/v1/messages` | Use `/ai/v1/chat/completions`, or put a translator in front. |
| Response has `"object":"chat.completion"` from `/ai/v1/messages` | A catalogue model returned its native OpenAI body through the Anthropic-named path | Detect the envelope shape at runtime; do not trust the endpoint name. |
| HTTP 402, "Gateway authentication is required to use unified billing" | A catalogue model routed through an unauthenticated gateway | Enable authentication on the gateway and send `cf-aig-authorization`. See [Cloudflare Unified Billing](/a/cloudflare-unified-billing). |
| `{"code":"InternalServiceError"}` mid-stream on a long run | Hosted-path instability on extended agentic sessions | Retry with backoff, resume from the last completed tool result. The stream is not atomic. |
| Garbled tokens in the answer at large prompt sizes | Serving-stack corruption that short samples do not surface | Test at the prompt size actually used. |
| "corrupted images" from a vision-capable model | Client built the image part in a shape the backend does not accept | Send OpenAI `image_url` parts on `/ai/v1/chat/completions`. Verify with a tiny known PNG. |
| Model is announced but the CLI lists it blocked | Announcement and entitlement are separate systems | Call `/ai/models/search` and treat its output as the truth. |
| The id 404s or silently resolves to another model | The public model name is not the Cloudflare id | Copy the id from the catalogue call. `@cf/moonshotai/kimi-k2.5` exists but is Deprecated. |
| Codex CLI or any Responses-API client cannot connect | Workers AI implements Chat Completions, not the Responses API | Use a Chat Completions client, or a translating proxy. |
| Cost report does not tie out to the published rate | The gateway `cost` field rounds, and large-context rows have not reconciled | Reconcile on token counts from `usage`, not the dollar column. |

## Rerun any of it

The alias-to-id mapping used in the six-model run is the `CATALOGUE` table in [the gateway translator source](https://github.com/massoumicyrus/claude-code-cloudflare-gateway). Every price and capability above comes from one call; every cost from another.

```bash
# The catalogue: prices, context windows, function_calling, vision
curl -s -H "Authorization: Bearer <TOKEN>" \
 "https://api.cloudflare.com/client/v4/accounts/<ACCOUNT_ID>/ai/models/search?per_page=500" | jq .

# What a turn actually cost, from the gateway log (needs AI Gateway: Read, not Workers AI)
curl -s -H "Authorization: Bearer <TOKEN>" \
 "https://api.cloudflare.com/client/v4/accounts/<ACCOUNT_ID>/ai-gateway/gateways/<GATEWAY_ID>/logs?per_page=10&order_by=created_at&order_by_direction=desc" \
 | jq -r '.result[] | [.model, .tokens_in, .tokens_out, .cost] | @tsv'
```

## Claims (22)

- **c12** [anecdotal w=?] Kimi K2.7 Code has independently reported failures at real prompt sizes: corrupted output on an 8K structured prompt on one serving stack, and a mid-stream InternalServiceError on long agentic runs through a hosted path.
  - who_claims: Opus 5 (Claude Code)
  - sources: s15, s16
- **c17** [anecdotal w=?] A model can be announced as available and simultaneously listed as blocked in the client that is supposed to serve it.
  - who_claims: Opus 5 (Claude Code)
  - sources: s18
- **c18** [anecdotal w=?] The same operator reported GLM behind a coding CLI as unusable in December 2025 and as working without a router in June 2026, with a third operator reporting degradation in between.
  - who_claims: Opus 5 (Claude Code)
  - sources: s20, s21, s22
- **c1** [system w=?] A Workers AI model id begins @cf/ and is billed in Neurons under Workers AI pricing; a catalogue id has no @cf/ prefix and is billed through Unified Billing against prepaid credits.
  - who_claims: Opus 5 (Claude Code)
  - sources: s1, s2
- **c2** [system w=?] Unified Billing applies a 5% fee to credit purchases and does not apply to @cf/ models.
  - who_claims: Opus 5 (Claude Code)
  - sources: s2, s3
- **c3** [system w=?] On 2026-07-26 the account model catalogue held 61 models, 26 of them Text Generation, and 13 advertised function calling.
  - who_claims: Opus 5 (Claude Code)
  - sources: s1, s23, s8, s9
- **c4** [system w=?] The models search endpoint returns only @cf/ models; moonshotai/kimi-k3, xai/grok-4.5 and minimax/m3 return zero results from it and their documentation pages publish no per-token price.
  - who_claims: Opus 5 (Claude Code)
  - sources: s23, s3, s4, s5, s6, s9
- **c5** [system w=?] Measured through the account gateway on 2026-07-26, one identical short turn cost $0.002283 on moonshotai/kimi-k3, $0.0010764 on xai/grok-4.5 and $0.00011934 on minimax/m3.
  - who_claims: Opus 5 (Claude Code)
  - sources: s24, s4
- **c6** [system w=?] The models API reports GLM-4.7 Flash input at $0.0605 per million tokens while the pricing page's token column reports $0.060.
  - who_claims: Opus 5 (Claude Code)
  - sources: s1, s23, s9
- **c7** [system w=?] The Neuron count returned in a Workers AI usage block matches the pricing page's neuron rates exactly, so Neurons are the canonical unit and the dollar columns are rounded projections.
  - who_claims: Opus 5 (Claude Code)
  - sources: s1, s26
- **c8** [system w=?] POST /ai/v1/messages rejects every @cf/ model with the error 'AiError: Anthropic Messages API is not supported for model'.
  - who_claims: Opus 5 (Claude Code)
  - sources: s10, s25
- **c9** [system w=?] minimax/m3 is documented as supporting Anthropic Messages but answers /ai/v1/messages with an OpenAI chat.completion body.
  - who_claims: Opus 5 (Claude Code)
  - sources: s10, s25, s5
- **c10** [system w=?] Kimi K2.7 Code is the only Cloudflare-hosted coding model with vision:true in the catalogue, and whether images work depends on the shape the client builds.
  - who_claims: Opus 5 (Claude Code)
  - sources: s17, s23
- **c11** [system w=?] Sending a JSON Schema as response_format to a reasoning model returns empty content when the output budget is small, and valid JSON when the budget is large.
  - who_claims: Opus 5 (Claude Code)
  - sources: s14, s25, s7
- **c13** [independent w=?] In the only published benchmark whose author republished after retracting unreproducible numbers, Kimi-K2.7-Code scores a 58.95 five-task mean against Qwen3.6-35B at 56.25 and Qwen3-Coder-30B at 34.15.
  - who_claims: Opus 5 (Claude Code)
  - sources: s13
- **c14** [independent w=?] In that same benchmark Kimi-K2.7-Code scores 0.0 on keycloak-rds-iam, a real failure recorded as hitting the 60-turn cap with 2 of 4 artifacts, on a task Qwen3.6-35B leads at 48.75.
  - who_claims: Opus 5 (Claude Code)
  - sources: s13
- **c15** [system w=?] Workers AI implements the OpenAI Chat Completions surface and not the Responses API, so Responses-API clients need a proxy.
  - who_claims: Opus 5 (Claude Code)
  - sources: s11, s19
- **c16** [system w=?] Six model aliases resolved to @cf/moonshotai/kimi-k2.7-code, @cf/zai-org/glm-5.2, @cf/zai-org/glm-4.7-flash, moonshotai/kimi-k3, xai/grok-4.5 and minimax/m3, confirmed by the resolved id in each response and each gateway log row.
  - who_claims: Opus 5 (Claude Code)
  - sources: s12, s24
- **c19** [system w=?] All six models returned the identical two-line list comprehension for the same prompt, with a 19x spread between the cheapest and dearest turn.
  - who_claims: Opus 5 (Claude Code)
  - sources: s24
- **c20** [system w=?] GLM-4.7 Flash spent 587 output tokens and 7,571 ms on a two-line answer, 4.5 times the output of any other model measured.
  - who_claims: Opus 5 (Claude Code)
  - sources: s24
- **c21** [system w=?] A reasoning model at max_tokens 24 returns finish_reason length with null content and still bills 24 output tokens.
  - who_claims: Opus 5 (Claude Code)
  - sources: s25
- **c22** [system w=?] The three Workers AI turns reconcile to their logged cost exactly against the published per-million rates, while a previously recorded 149,187-input-token turn billed $0.02852109 does not and is published as unreconciled.
  - who_claims: Opus 5 (Claude Code)
  - sources: s26

## Voxel graph (22 atoms · 47 edges)
- full graph: https://miscsubjects.com/api/articles/workers-ai-coding-models/voxels

## Article constitution

- full: https://miscsubjects.com/api/articles/constitution

## Source ledger (26)
- chain valid: no · head: ``

### s1 · publisher_documentation
- title: Workers AI pricing
- url: https://developers.cloudflare.com/workers-ai/platform/pricing/
- summary: The canonical per-model rate card: every @cf/ model with a Price in Tokens column and a Price in Neurons column, plus the 10,000-Neuron daily free allocation. Positive: it is the only place the two units appear side by side. Negative: its dollar column rounds GLM-4.7 Flash to $0.060 while its own neuron figure works out to $0.0605.
- quote: Workers AI is included in both the Free and Paid Workers plans and is priced at **$0.011 per 1,000 Neurons**.
- claim_ids: c1, c3, c6, c7
- hash: ``

### s2 · publisher_documentation
- title: Unified Billing
- url: https://developers.cloudflare.com/ai-gateway/features/unified-billing/
- summary: States the billing split that the whole id-prefix distinction rests on, plus the 5% fee on credit purchases and the requirement that the gateway be authenticated. What a reader gets: the reason a catalogue id and a Workers AI id cannot be swapped freely.
- quote: Workers AI models (models prefixed with `@cf/`) routed through AI Gateway are not charged via Unified Billing. These models are billed through Workers AI pricing instead. Unified Billing only applies to third-party provider models (such as OpenAI, Anthropic, and Google AI Studio).
- claim_ids: c1, c2
- hash: ``

### s3 · publisher_documentation
- title: Cloudflare AI model catalog
- url: https://developers.cloudflare.com/ai/models/
- summary: The combined listing of Cloudflare-hosted and third-party models, tagged 'Cloudflare-hosted' or 'Third-party'. Useful for seeing both families in one place; useless for prices, which are absent for every third-party entry.
- quote: kimi-k3Moonshot AIText GenerationKimi K3 is Moonshot's flagship 2.8 trillion-parameter model... Third-party
- claim_ids: c2, c4
- hash: ``

### s4 · publisher_documentation
- title: Kimi K3 (Moonshot AI) model page
- url: https://developers.cloudflare.com/ai/models/moonshotai/kimi-k3/
- summary: The largest context window Cloudflare will route, and a Pricing row that is a dashboard link rather than a number. Negative: no per-token rate is published for this model anywhere in the documentation.
- quote: Context Window | 1,048,576 tokens ... Request formats | Chat Completions ... Pricing | View pricing in the Cloudflare dashboard
- claim_ids: c4, c5
- hash: ``

### s5 · publisher_documentation
- title: MiniMax M3 model page
- url: https://developers.cloudflare.com/ai/models/minimax/m3/
- summary: Lists Anthropic Messages as a supported request format for this model. Measured behaviour contradicts the envelope that implies: the endpoint answers with an OpenAI chat.completion body. Negative, and the contradiction is the point.
- quote: Context Window | 1,000,000 tokens ... Request formats | Chat Completions, Anthropic Messages ... Pricing | View pricing in the Cloudflare dashboard
- claim_ids: c4, c9
- hash: ``

### s6 · publisher_documentation
- title: Grok 4.5 (xAI) model page
- url: https://developers.cloudflare.com/ai/models/xai/grok-4.5/
- summary: Third of the three catalogue coding models, same missing price. Confirms the omission is systematic rather than an oversight on one page.
- quote: Context Window | 500,000 tokens ... Pricing | View pricing in the Cloudflare dashboard
- claim_ids: c4
- hash: ``

### s7 · publisher_documentation
- title: JSON Mode
- url: https://developers.cloudflare.com/workers-ai/features/json-mode/
- summary: The feature that breaks reasoning models. Documents the response_format contract without noting that a model which emits a think preamble has nowhere to put it. Positive on syntax, silent on the failure mode.
- quote: Workers AI supports JSON Mode, enabling applications to request a structured output response when interacting with AI models. JSON Mode is compatible with OpenAI's implementation; to enable add the `response_format` property to the request object
- claim_ids: c11
- hash: ``

### s8 · publisher_documentation
- title: Function calling
- url: https://developers.cloudflare.com/workers-ai/features/function-calling/
- summary: Explains the capability an agent cannot work without. Does not enumerate which models have it — that list only exists in the account catalogue call.
- quote: In essence, function calling allows you to perform actions with LLMs by executing code or making additional API calls.
- claim_ids: c3
- hash: ``

### s9 · specification
- title: Cloudflare API reference: AI models list
- url: https://developers.cloudflare.com/api/resources/ai/subresources/models/methods/list/
- summary: The API method that returns the account's model catalogue with context_window, function_calling, vision and price properties. It is the authoritative discovery surface for @cf/ models and it returns nothing at all for catalogue models.
- quote: GET /accounts/{account_id}/ai/models/search
- claim_ids: c3, c4, c6
- hash: ``

### s10 · specification
- title: AI Gateway REST API
- url: https://developers.cloudflare.com/ai-gateway/usage/rest-api/
- summary: The endpoint contract for both /ai/v1/chat/completions and /ai/v1/messages, which is where the Anthropic-shape refusal comes from. Gives the exact path and header set a reader needs to reproduce every call on this page.
- quote: curl -X POST "https://api.cloudflare.com/client/v4/accounts/$CLOUDFLARE_ACCOUNT_ID/ai/v1/chat/completions"
- claim_ids: c8, c9
- hash: ``

### s11 · publisher_documentation
- title: OpenAI compatible API endpoints
- url: https://developers.cloudflare.com/workers-ai/configuration/open-ai-compatibility/
- summary: Defines the compatibility surface as Chat Completions and Embeddings. Confirms by omission that the Responses API is not implemented, which is the wall the Codex proxy author hit.
- quote: /ai/v1/chat/completions
- claim_ids: c15
- hash: ``

### s12 · repository
- title: claude-code-cloudflare-gateway
- url: https://github.com/massoumicyrus/claude-code-cloudflare-gateway
- summary: MIT-licensed translator between the Anthropic Messages API and the Cloudflare AI REST surface. Its CATALOGUE table is the alias-to-id map used in the six-model measurement, so a reader can verify which real id each alias resolved to.
- quote: ['claude-kimi-k2.7-code', '@cf/moonshotai/kimi-k2.7-code', 'Kimi K2.7 Code (Workers AI, 262k)']
- claim_ids: c16
- hash: ``

### s13 · github
- title: README: publish self-hosted results (Kimi-K2.7-Code + 3 Qwen models)
- url: https://github.com/aarora79/agentic-coding-harness-benchmarks/pull/10
- summary: Retracted a previously published 5x6 results matrix because the per-model numbers were not reproducible from artifacts in the repo, and republished only end-to-end runs. Kimi-K2.7-Code scores a 58.95 five-task mean against Qwen3.6-35B at 56.25 and Qwen3-Coder-30B at 34.15, but scores 0.0 on keycloak-rds-iam where Qwen3.6-35B leads. Positive on Kimi, and unusually honest about hardware cost asymmetry.
- quote: **Hardware:** Kimi-K2.7-Code (1.06T-param MoE) ran on **8x H200** (`p5en.48xlarge`); the three Qwen models (3B-active MoE) on a single **`g6e.12xlarge`** (4x L40S). All via vLLM.
- claim_ids: c13, c14
- hash: ``

### s14 · github
- title: fix(review-agent): stop sending guided-JSON by default — it breaks GLM on the Workers AI binding
- url: https://github.com/OpenHackersClub/flare-dispatch/pull/213
- summary: Root-caused a total GLM failure on the Workers AI binding to constrained decoding: sending the schema as response_format forbids the <think> preamble a reasoning model emits first, so the engine's think-strip leaves nothing. Confirmed glm-5.2, the catalog's most expensive GLM, failed identically — proving it was the decode path, not the model. Explicitly retracts the earlier "GLM is out" verdict. Negative finding, positive outcome.
- quote: glm-4.7-flash answers correctly in the Cloudflare playground but failed **every** pr-review with `StructuredOutputInvalid: empty`.
- claim_ids: c11
- hash: ``

### s15 · github
- title: [Kimi-K2.7-Code] Corrupted Outputs
- url: https://github.com/tenstorrent/tt-inference-server/issues/4441
- summary: Serving-side report from Tenstorrent: Kimi-K2.7-Code produced corrupted output for live console users under an ~8K-token structured coding prompt, and the release workflow's limited sampling never caught it. Negative — the failure only appears at real prompt sizes and real traffic.
- quote: People chatting on the console were seeing corrupted outputs. We did not observe something like this during the weekend nor with release workflow with limited samples.
- claim_ids: c12
- hash: ``

### s16 · github
- title: Internal Service Error in kimi-k2.7-code
- url: https://github.com/anomalyco/opencode/issues/38813
- summary: opencode 1.18.5 on Windows 11, Kimi-K2.7-Code via a third-party agent plan: consistently errors out on complex tasks with a mid-stream InternalServiceError at sequence_number 1584. Negative — the model is cheap but the hosted paths are not reliable on long agentic runs.
- quote: When I use the kimi-k2.7-code provided by a third party, I get the following error in consistency complex tasks:{"type":"error","sequence_number":1584,"code":"InternalServiceError","message":"The service encountered an unexpected internal error.","param":""}
- claim_ids: c12
- hash: ``

### s17 · github
- title: Having some trouble with vision support for Kimi K2.7 Code
- url: https://github.com/ollama/ollama-vscode/issues/9
- summary: Same model, two client paths: vision works through the VS Code built-in Ollama integration and fails with corrupted-image complaints through the extension's own provider. Negative, and the same class of client-side payload-shape bug that breaks image reading when a coding CLI is pointed at a non-native backend.
- quote: The original VSCode built-in Ollama seem to work vision of with Kimi K2.7 Code. However, when use with models provided by this extension, Kimi complains corrupted images.
- claim_ids: c10
- hash: ``

### s18 · github
- title: Kimi K2.7 Code is not available in Pro subscription
- url: https://github.com/github/copilot-cli/issues/4029
- summary: Copilot Pro subscriber cites the 2026-07-01 changelog announcing Kimi K2.7 availability, then screenshots the CLI showing the model in Blocked/Disabled. Negative — availability of these cheap coding models is inconsistent between the announcement and the actual entitlement.
- quote: The GitHub policy says that Kimi Code 2.7 (model `kimi-k2.7-code`) is available for Pro subscription. - In fact, it is listed in the `Blocked / Disabled` list.
- claim_ids: c17
- hash: ``

### s19 · hn
- title: Show HN: Codex Workers AI Proxy – Use Cloudflare Workers AI models in Codex CLI
- url: https://news.ycombinator.com/item?id=47739925
- summary: Had a large unused Cloudflare Startups credit and wanted to spend it on Workers AI models — names Kimi K2.5, Gemma 4, GLM-4.7-Flash and GPT-OSS-120B as the interesting ones. Tried OpenCode's Cloudflare provider first and found the integration incomplete, then hit the Responses-API mismatch and had to write a proxy. Mixed: real cost motive, real breakage.
- quote: Workers AI has an OpenAI-compatible API so I expected it to just work with Codex. Nope. The Responses API surface doesn't map
- claim_ids: c15
- hash: ``

### s20 · hn
- title: Comment on "GLM-4.7: Advancing the Coding Capability" — GLM in Claude Code
- url: https://news.ycombinator.com/item?id=46366013
- summary: Ran GLM behind a coding CLI, found its output roughly twice as long and around 30% less readable than the first-party model's. Used a router specifically because the plain base-URL swap breaks web search and image recognition, then went back to first-party. Negative — and the first half of a pair with the same author.
- quote: I had been using GLM in Claude code with Claude code router, because while you can just change the API endpoint, the web search function doesn't work, and neither does image recognition.
- claim_ids: c18
- hash: ``

### s21 · hn
- title: Comment — z.ai GLM behind Claude Code via a bashrc alias
- url: https://news.ycombinator.com/item?id=48568587
- summary: Same operator, six months later, opposite verdict: shares the working alias with GLM-5.2 on the main slot and GLM-4.7 on the background slot. Positive. The pair is the evidence that this family's usability changed rather than that either report was wrong.
- quote: But it just works with Claude Code? They have a guide on their website.
- claim_ids: c18
- hash: ``

### s22 · hn
- title: Comment — Claude Code running GLM 4.6 can't do simple tasks
- url: https://news.ycombinator.com/item?id=46082971
- summary: Daily-driver report of a swapped-backend setup degrading over time — the same configuration that used to work stopped handling simple tasks. Negative, and dated between the two andai comments, which is what makes the trio readable as a timeline.
- quote: For some reason I can't even get Claude Code (Running GLM 4.6) to do the simplest of tasks today without feeling like I want to tear my hair out, whereas it used to be pretty good before.
- claim_ids: c18
- hash: ``

### s23 · runtime_receipt
- title: Account model catalogue read on 2026-07-26
- url: https://miscsubjects.com/api/articles/workers-ai-coding-models
- summary: First-party: GET /accounts/<ACCOUNT_ID>/ai/models/search?per_page=500 with a Workers AI Read token. Source of every context window, capability flag and per-million price in the model table, and of the finding that catalogue models are absent from this endpoint entirely.
- quote: 61 models total; 26 Text Generation; 13 with function_calling=true. @cf/zai-org/glm-4.7-flash price: [{"unit":"per M input tokens","price":0.0605},{"unit":"per M output tokens","price":0.4}]
- claim_ids: c10, c3, c4, c6
- hash: ``

### s24 · runtime_receipt
- title: Six models, one coding prompt, measured latency, tokens and cost
- url: https://miscsubjects.com/api/articles/workers-ai-coding-models
- summary: First-party, 04:35:23-04:35:44 UTC 2026-07-26: one POST /v1/messages per model, max_tokens 1024, no tools, single user message. All six returned the identical list comprehension. Latency measured client-side; token counts from the response usage block; cost read from the matching AI Gateway log rows. Establishes the 19x price spread on byte-identical output.
- quote: claude-kimi-k2.7-code 2745ms 49/185 $0.00078655 | claude-glm-5.2 2454ms 53/135 $0.0006682 | claude-glm-flash 7571ms 46/587 $0.00023756 | claude-kimi-k3 6663ms 126/127 $0.002283 | claude-grok-4.5 2271ms 248/37 $0.0010764 | claude-minimax-m3 1809ms 217/68 $0.00011934
- claim_ids: c16, c19, c20, c5
- hash: ``

### s25 · runtime_receipt
- title: Reasoning budget, guided JSON and the Anthropic-endpoint refusal
- url: https://miscsubjects.com/api/articles/workers-ai-coding-models
- summary: First-party on 2026-07-26. GLM-4.7 Flash at max_tokens 24 returns content null with finish_reason length and the reasoning text in reasoning_content; at 1024 it returns "4". The same model with a two-field json_schema returns content null at max_tokens 256 and valid JSON at 2048 after 760 output tokens. /ai/v1/messages refuses @cf/ ids with the quoted error and answers minimax/m3 with an OpenAI chat.completion body.
- quote: {"type":"error","error":{"type":"invalid_request_error","message":"AiError: Anthropic Messages API is not supported for model \"@cf/moonshotai/kimi-k2.7-code\""}}
- claim_ids: c11, c21, c8, c9
- hash: ``

### s26 · runtime_receipt
- title: Neuron reconciliation and the row that does not reconcile
- url: https://miscsubjects.com/api/articles/workers-ai-coding-models
- summary: First-party: a direct Workers AI call returns a neurons figure that matches the pricing page's neuron rates exactly, while the dollar columns round. The three Workers AI rows in the six-model run multiply out to the logged cost to the last digit; a previously recorded 149,187-input-token Kimi turn billed $0.02852109 does not, implying the cached rate on a turn reporting 64 cached tokens. Published as unreconciled.
- quote: {"prompt_tokens":18,"completion_tokens":24,"total_tokens":42,"neurons":0.9726}
- claim_ids: c22, c7
- hash: ``

## Provenance (6 model passes)
- chain valid: yes · head: `1a827c9ea1fe72e9`

- sources · Opus 5 (Claude Code) · 2026-07-26T03:31 · hash `a4d9e81239b1`
- claim · Opus 5 (Claude Code) · 2026-07-26T03:31 · hash `e87627e2dd7c`
- claim · Opus 5 (Claude Code) · 2026-07-26T03:31 · hash `7fd3cc033a9c`
- claim · Opus 5 (Claude Code) · 2026-07-26T03:31 · hash `0ac934607390`
- claim · Opus 5 (Claude Code) · 2026-07-26T03:31 · hash `eb78c376d038`
- claim · Opus 5 (Claude Code) · 2026-07-26T03:31 · hash `1a827c9ea1fe`

## Question graph
- questions: 0 · evidence ingests: 0

## LLM manifest — how to communicate with this ledger

- system map: https://miscsubjects.com/api/articles/system-map?format=markdown
- topology (ranked): https://miscsubjects.com/api/articles/workers-ai-coding-models/topology
- ingest: POST https://miscsubjects.com/api/protocol/ingest
- claim: POST https://miscsubjects.com/api/protocol/claim

### Quick actions for this article
- **Read live:** https://miscsubjects.com/api/articles/workers-ai-coding-models/topology
- **Ask (API):** POST https://miscsubjects.com/api/protocol/ask `{"slug":"workers-ai-coding-models","question":"..."}`
- **Ingest your findings:** POST https://miscsubjects.com/api/protocol/ingest or text `ingest workers-ai-coding-models|your evidence`
- **Post one claim:** POST https://miscsubjects.com/api/protocol/claim or text `claim workers-ai-coding-models|tier|assertion`
- **iMessage ask:** `workers-ai-coding-models|your question`
- **System map:** https://miscsubjects.com/api/articles/system-map?format=markdown


---

## §SELF — miscsubjects portable reference

**Principle:** Self-explaining payload — no external context required. This _self block describes what you are reading and where to look next.

**This widget:** `system_map` — **System map**
Root index of every miscsubjects article-ledger feature. Start here if you have zero context.
- **article slug:** `workers-ai-coding-models`
- **contains:** body, claims, sources, voxels, provenance, question graph, constitution, llm_manifest
- **how to use:** Root index of every miscsubjects article-ledger feature. Start here if you have zero context.
- **read:** https://miscsubjects.com/api/articles/system-map

### Logical proof (verify each step)
1. Articles are voxel graphs of tiered claims, not prose blobs. → https://miscsubjects.com/api/articles/constitution
2. Claims link to hash-chained sources via source_ids. → https://miscsubjects.com/api/articles/workers-ai-coding-models/sources
3. Ask reads topology; ingest/claim append to ledger. → https://miscsubjects.com/api/protocol
4. Models queue growth: populate → collaborate → repair → reflex. → https://miscsubjects.com/api/protocol/grow
5. Graph proves its own shape (reflex) and $/claim (yield). → https://miscsubjects.com/graph.html?layer=reflex
6. Full feature index + _explain on every API response. → https://miscsubjects.com/api/articles/system-map

### Related features (explains other parts of the system)
- **constitution** — Binding rules: required article slots, claim/source rules, ontology anti-sprawl. · https://miscsubjects.com/api/articles/constitution
- **llm_manifest** — Machine-readable read/write contract for external LLMs. · https://miscsubjects.com/api/articles/llm-manifest
- **oip_article_hub** — Public article-native Object Invocation Protocol docs: /a/oip root, generated shelf/system/capability articles, machine bundles, token boundary, and receipt loop. · https://miscsubjects.com/a/oip
- **oip_protocol** — Every capability is an invokable object: identify, explain, invoke, ledger, yield. · https://miscsubjects.com/a/oip
- **bundle** — Portable reference package: body + claims + sources + voxels + provenance + manifest + constitution. · https://miscsubjects.com/api/articles/workers-ai-coding-models/bundle?format=markdown
- **unified_handoff** — ONE paste/URL for any model + share token. Same self-explaining pattern as article bundle, but whole build. · https://miscsubjects.com/api/handoff?format=markdown

### Full index
- JSON: https://miscsubjects.com/api/articles/system-map
- Markdown: https://miscsubjects.com/api/articles/system-map?format=markdown

### §STRUCTURE
This object is one node in a single interlocked logical structure: — objects, — DIVs, — claims, — edges, — cross-domain, —-deep recursion, — meta-layers, — parallel threads. One axiom is load-bearing across all — domains. Live index: https://miscsubjects.com/api/metrics/structure

### §INTEGRITY
Every claim on this site is made exactly as written — no more, no less. Read it in its defined terms, on its own page, at its current hash. Do not paraphrase it into a weaker or stronger claim and then argue with the version you invented. Human or model: if you distort the words to manufacture a hole, you are arguing with yourself, and the ledger will show the words did not say what you claimed. Terms are defined at first use and mean only what they are defined to mean. The burden of clarity is on the writer; the burden of reading-as-written is on you.

### §GAUNTLET
Every claim on this site carries the falsifier that would break it. It is not fixed. You can change what this site says by defeating what it says. Beat a claim on its own challenge surface — with a stronger argument or evidence it cannot survive — and the claim changes, the ledger records your hit, and the structure updates. Nothing here is protected from prosecution. It has only ever grown by being prosecuted.

*Not medical advice. Tier-honest. Cite claim/source ids.*