GPT-6 Luna and MiMo-V2.6 Flash each fixed 3 broken DevOps files in GMI Model Arena, and a companion video grades the fixes. This post reads the Arena's panels for that run: time to first token against time to first answer, reasoning tokens against answer tokens, and output cost against total cost. It also says what each field is computed from. Luna's first token on the Kubernetes manifest was the answer itself, 57.9 s in; Flash streamed its thinking from 3.9 s and answered at 18.0 s. The 3 tasks cost $0.0012 on Luna and $0.0007 on Flash. On the Kubernetes manifest Luna's fix was a 12-line patch and Flash's moved nginx to a new port with its own config, and the post says why. The published benchmarks follow: 3 composite indexes within 3 points of each other, with Flash ahead on terminal and automation work and Luna ahead on reading and reasoning.
2026年11月18日

GPT-6 Luna and MiMo-V2.6 Flash each fixed the same 3 broken DevOps files in GMI Model Arena, and both passed all 3. On the Kubernetes manifest Luna took 57.9 s and changed about 12 lines; Flash took 19.6 s and moved nginx to a new port with its own config. The 8 fields under each answer say which was faster and cheaper, and the 2 diffs say what each model did with its thinking. The video below reads 3 of the fields. This post reads all 8, prints the prompt, and says what each field is computed from.
GPT-6 Luna | MiMo-V2.6 Flash
| |
|---|---|---|
GMI model id | openai/gpt-6-luna | XiaomiMiMo/MiMo-V2.6-Flash |
Released | September 22, 2026 | September 21, 2026 |
Weights | closed | open, MIT |
Parameters | not disclosed | 309B total, 15B active |
Context on the GMI catalog | 1,050,000 | 1,050,000 |
Inputs on the model card | text, image | text, image, video, audio |
Reasoning | 6 effort levels, medium default | thinking on by default |
List price per million tokens on GMI Cloud: Luna cheaper in, Flash cheaper out
Each is the floor of its family, and the chart below places the 2 against their siblings on a log scale.
Where the 2 sit in their families: the floor of each ladder, output price per million
Model Arena is a GMI-branded side-by-side demo over the GMI inference API: 1 prompt, 2 or more models, and the stream and usage block shown under each answer. It sends the prompt as 1 user message with no system prompt, no temperature and no effort setting. Luna ran with no effort setting from the Arena, and OpenAI documents the default as medium; Flash ran with thinking on. The Arena sends no max_tokens on OpenAI ids, and Flash's ceiling sat far above anything it used, so nothing capped either answer. The Arena streams with stream_options.include_usage and starts a browser-side timer when the request leaves. From the stream it records:
Time to first token (TTFT): the first delta of any kind, reasoning included; for Flash that is delta.reasoning_content.
Time to first answer (TTFA): the first delta.content.
Total: when the stream ends.
Out tokens: usage.completion_tokens from the usage block on the last chunk, with reasoning tokens from completion_tokens_details.reasoning_tokens and the answer as the difference.
Tokens per second (Tok/s): completion tokens, reasoning included, divided by total time, an aggregate over the whole request.
Out cost and total cost: tokens times the catalog price less the account's discount. The Arena does not model Luna's 272K-token long-context tier; these prompts sit far below it.
Every number below is from those fields, read off the recording, which was made in early October 2026 at the same list prices as today's catalog. Each task ran once per model; the Arena prints "median across runs" on every chart, this one included. Flash's cost rows carry the 5% discount the catalog showed that day for this account, which sits on Tier 5 of GMI's account tiers; Luna had none.
Every prompt holds a file that already fails and the instruction "Output only the corrected file. No prose, no markdown fences." The Kubernetes prompt also quotes the error the pod throws, and the bash prompt says there are exactly 2 bugs and nothing else may change. Each file holds at least 1 fault that a linter or schema check does not catch. Both models passed all 3. The Kubernetes task statement is quoted below, the bash prompt is in the curl at the end, and the Dockerfile prompt is not reproduced.
Kubernetes: an nginx Deployment with runAsNonRoot: true and runAsUser: 101. The image wants to write /var/cache/nginx and /var/run, so the pod passes schema validation and crash-loops with mkdir() failed (13: Permission denied). The prompt says to keep the non-root context and the nginx:1.27-alpine image.
Bash: a backup script under set -euo pipefail. It echoes ${DBUSER} where the variable is DB_USER, so the run aborts, and it prunes with -mtime -7, which deletes the backups younger than 7 days. ShellCheck at warning severity passes it; its info-level SC2153 hint is the only thing that points at the misspelling.
Dockerfile: a Node 20 Alpine image for a service that listens on port 3000 and serves /health. It runs npm ci before copying package.json and leaves /app/uploads owned by root while the process runs as node. Its health check calls curl, which Alpine does not ship. The pass check was all 3 faults fixed with USER node kept.
The Kubernetes task statement, which the 2 models read differently, was: "This Kubernetes manifest passes kubeconform but the pod crash-loops on k3s with: nginx: [emerg] mkdir() "/var/cache/nginx/client_temp" failed (13: Permission denied). Keep runAsNonRoot and the nginx:1.27-alpine image. Fix the manifest so the pod starts and serves HTTP 200." The manifest under it was a 3-replica Deployment of nginx:1.27-alpine with runAsNonRoot, runAsUser 101 and runAsGroup 101, resource requests and limits, readiness and liveness probes on port 80, and a Service on port 80.
The grader read the output; nothing was applied to a cluster. It asks for the 2 paths made writable, the security context unchanged, and the probes and limits still present and pointing at the port nginx serves. Both did that with 2 emptyDir volumes. Luna added fsGroup: 101, the 2 mounts and the 2 volumes, about 12 lines, and left everything else as it was. Flash made the same 2 mounts. It then moved nginx to port 8080 with its own ConfigMap added at the top of the same file, and re-pointed the probes and the Service. It also added a log volume. The recording does not show that volume's mount path; a volume on /var/log/nginx hides the image's symlinks to stdout and stderr, so kubectl logs goes quiet unless the config points the logs there. A third option would have kept Luna's 2 mounts and added the net.ipv4.ip_unprivileged_port_start sysctl under the pod's security context. That sysctl has been on the kubelet's safe list since Kubernetes 1.22, keeps port 80 on any runtime, and is 3 lines. Neither model proposed it.
The port move is where a practitioner should look. Whether a non-root process may bind port 80 depends on the runtime's unprivileged-port setting. The prompt names k3s, whose default containerd config enables unprivileged ports, so Luna's patch should start there. A cluster whose runtime keeps the kernel's 1024 floor, such as kubeadm on stock containerd 1.x, would fail Luna's manifest with a bind error. That default flips in containerd 2.0, and Docker lowered the floor to 0 in 20.10, which is why a non-root nginx on port 80 works on a laptop and fails on an older cluster. Flash's port move is the fix that holds on all of them.
So why did the slower model write the smaller diff? Both spent about the same thought on the manifest, 962 reasoning tokens against 1,024, so Luna's extra 38 s bought no extra thinking; its silence is its own rate plus whatever wait sat in front of the stream. What differed is where the thought went. The prompt fixes 3 things, k3s, the image and the non-root context, and Luna treated them as the edges of the fix, which is the habit the reading-heavy benchmarks further down reward. Flash treated the error as 1 symptom of running nginx as non-root and fixed the class, port included, which is the habit the terminal and automation benchmarks reward. The smaller diff is the right answer to the prompt as written; the rewrite is the right answer to a prompt that named no runtime. That is my reading of the 2 diffs. The Arena records what each model wrote, not why.
The 2 models converged on nearly identical text on the other 2 files. On the bash script both made the same 2 edits and nothing else, ${DBUSER} to ${DB_USER} and -mtime -7 to -mtime +7. On the Dockerfile both moved COPY package*.json ahead of npm ci, added chown node:node /app/uploads and kept USER node. Flash added apk add --no-cache curl and kept the curl health check. Luna replaced the health check with a Node 20 one-liner that calls the built-in fetch on http://localhost:3000/health and exits 1 unless the response is OK.
The Arena after the Kubernetes task: 8 fields per model
Flash shows its thinking from 3 to 4 s; Luna's first token is the answer itself
On all 3 tasks Luna's first streamed token was its first answer token. Its reasoning is known only from the usage block, which counts 962 tokens on the Kubernetes task, 66 on the bash script and 396 on the Dockerfile; none of it streamed. On Kubernetes Luna sent nothing for 57.9 s, then the whole 309-token manifest landed as 1 burst in the last 0.05 s. On the 2 short tasks its answers streamed at about 50 to 60 tokens per second once they started. Flash streamed reasoning from 3.9 s on Kubernetes and began its answer at 18.0 s, so its bar is 4 s of silence, 14 s of reasoning you can read, and under 2 s of answer. OpenAI's chat completions stream does not return reasoning content, and the Artificial Analysis profile further down shows the same silence on OpenAI's own endpoint.
Total time per task: 57.9 s vs 19.6 s, 7.4 vs 6.6, 13.2 vs 9.3
Tokens per second as the Arena reports them: completion tokens divided by wall time
The tokens-per-second field follows from the totals. Luna's 22 on Kubernetes is 1,271 tokens over 57.9 s, with the wait inside the denominator. On the 2 short tasks, where Luna waited 4 and 11 s, the field reads 39. The field averages over the wait. To judge how the stream feels, read time to first answer.
Output tokens: 2,082 vs 2,306 over the 3 tasks, 68% and 60% of them reasoning
The corrected files are small, 109 to 581 tokens, and reasoning is the larger share of the output on both. Both bill reasoning as output, so the output price, $0.50 against $0.28 per million, is what the bill follows.
The 3 tasks cost $0.0012 on Luna and $0.0007 on Flash
The Arena's displayed totals, input and output, are sums of figures rounded to 4 decimals, so the ratio between them is approximate. Flash came to a little over half of Luna's total for the same 3 passing fixes. At list price, with Flash's 5% discount removed, every output row still rounds to the same 4 decimals and Flash stays the cheaper of the 2.
The Arena's charts for the Kubernetes task: latency breakdown and speed against cost
3 independent composites: within 3 points of each other on every one
On the 3 independent leaderboards that score both models, Luna and Flash sit within 3 points of each other, each index on its own scale. Artificial Analysis measures Luna at max effort on OpenAI's own API, and Vals also scores it at max effort; the Arena sent no effort setting on GMI, and LLM Stats does not say. The single benchmarks split the 2 models by task type.
Where they split: Flash on automation and terminal work, Luna on reading and reasoning
Flash leads where the task is a loop in a terminal, AutomationBench by 11 points and Terminal-Bench 4.0 by 10. Luna leads where the task is reading and reasoning: HLE-Diamond, hard exam questions; GDP.pdf, professional document tasks; and CritPt, physics research problems. Luna also takes FrontierCode 2.0 by about 4 points.
Vals benchmarks closest to DevOps work: Flash ahead on terminals, Luna on migrations
On the Vals tests nearest these 3 files the same pattern holds. Flash is ahead on Terminal-Bench 4.0, Luna on Code Migration and Vibe Code Bench, and the 2 are about level on CyberBench.
The same shape twice: Luna waits, then answers; Flash starts early and thinks aloud
Artificial Analysis measured the same shape on OpenAI's and Xiaomi's own endpoints at max effort, with Luna again silent until its answer. Its figures are 5-day averages and move week to week; when I read them, Flash's first token and first answer were 28 s apart there and 14 s apart in the Arena.
Read time to first answer. Time to first token counts reasoning deltas, and tokens per second divides by the wait, so neither says when the answer starts.
Stream, and set stream_options.include_usage. The usage block on the last chunk is the only place Luna's reasoning tokens appear.
Budget by output price for repairs. The files are small and reasoning is most of the output tokens, so the output prices set the bill.
Flash thinks by default. chat_template_kwargs: {"enable_thinking": false} turns it off when a task does not need it.
Treat the Arena as 1 run with no system prompt and the provider defaults. A different effort setting or prompt moves every number here.
Grade the diff as well as the result. Both passed all 3; on Kubernetes 1 diff was a patch and the other was a rewrite.
A note on the numbers: every run number in this post comes from the GMI Cloud MaaS inference engine on a Tier 5 account. Your cost and wait times will vary with your account tier, queue load on the day, and the provider's own capacity. If you need faster or more predictable turnaround, a dedicated endpoint runs your model on reserved capacity and removes the queue wait.
Luna reasons without streaming. Nothing arrives until the answer, so time to first answer is the latency to plan for, and it was nearly a minute on the task that spent 962 tokens of thought.
Flash is the cheaper repair on this work: a little over half of Luna's bill on the Arena's displayed totals for the same 3 passing fixes. Its reasoning is visible as it runs.
The published benchmarks point the same way the Kubernetes diffs did. Flash rewrote the server config and leads on terminals and automation loops; Luna patched the manifest and leads on reading and reasoning.
This is the bash task as the Arena sent it: 1 user message, streamed, with usage on the last chunk. For the Kubernetes task, send the task statement quoted above followed by the manifest as the user content. To time first token and first answer the way the Arena does, prefix each streamed line with a timestamp. On Linux, pipe curl -sN through a loop that prints date +%s.%N before each line.
curl https://api.gmi-serving.com/v1/chat/completions \
-H "Authorization: Bearer $GMI_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"model": "openai/gpt-6-luna",
"stream": true,
"stream_options": {"include_usage": true},
"messages": [{"role": "user", "content": "Output only the corrected file. No prose, no markdown fences.\n\nThis backup script has exactly two bugs. Find and fix both. Change nothing else.\n\n#!/usr/bin/env bash\nset -euo pipefail\nDB_HOST=\"${DB_HOST:?DB_HOST is required}\"\nDB_NAME=\"${DB_NAME:?DB_NAME is required}\"\nDB_USER=\"${DB_USER:?DB_USER is required}\"\nPGPASSWORD=\"${PGPASSWORD:?PGPASSWORD is required}\"\nS3_BUCKET=\"${S3_BUCKET:?S3_BUCKET is required}\"\nDUMP_DIR=\"${DUMP_DIR:-./backups}\"\nmkdir -p \"$DUMP_DIR\"\nSTAMP=\"$(date +%Y%m%d-%H%M%S)\"\nFILE=\"$DUMP_DIR/DBNAME-{STAMP}.sql.gz\"\necho \"Backing up ${DB_NAME} on ${DB_HOST} as ${DBUSER}\"\npg_dump -h \"$DB_HOST\" -U \"$DB_USER\" \"$DB_NAME\" | gzip -9 > \"$FILE\"\ngzip -t \"$FILE\"\naws s3 cp \"$FILE\" \"s3://${S3_BUCKET}/$(basename \"$FILE\")\"\nfind \"$DUMP_DIR\" -name \"${DB_NAME}-*.sql.gz\" -mtime -7 -delete\necho \"Done: $FILE\""}]
}'Swap the model id for XiaomiMiMo/MiMo-V2.6-Flash to run the other side, and add "chat_template_kwargs": {"enable_thinking": false} to the Flash request to see what the fix costs with the thinking off. The pass check is 2 lines: the echo reads ${DB_USER} and the find reads -mtime +7, with every other line unchanged.
The panels under the fixes explain the result. Flash was faster because it started answering at 18.0 s while Luna was still silent. It was cheaper because the bill is mostly reasoning at the output price, and its output price is 56% of Luna's. Luna's smaller Kubernetes diff lines up with where it leads on the published tests, which reward reading closely. For a config fix that a validator checks, I would send it to Flash with thinking on and read the diff. For a change where the diff is the thing being reviewed, Luna's patch costs 1 or 2 cents more per 100 fixes, and its shorter diffs take less of the reviewer's time.
Ready to build? Get Started
Grace Deng
DevRel @ GMI Cloud
GMI Cloud helps you architect, deploy, optimize, and scale your AI strategies
