# Coding models compared: Opus 5.5, Kimi, Qwen3-Coder, MiniMax

URL: https://infro.io/blog/coding-models-compared-2026
Author: INFRO Editorial (https://infro.io/blog/editorial)
Publisher: INFRO
Published: 2026-09-29
Last modified: 2026-09-29
Last reviewed: 2026-09-29 (next review due 2026-10-29)
Topic: Evaluation and models
Format: Comparison

> Claude Opus 5.5 lists $4/$20 per million input/output tokens with a 1M window; Kimi K2.7 Code $0.95/$4 with 262,144 tokens; Qwen3-Coder (qwen3-coder-plus) starts at $1/$5 but rises through four prompt-length tiers to $6/$60; MiniMax M3 lists $0.30/$1.20 up to 512K input. Coding agents send large, repetitive prompts, so prompt-length tiers and cache rates matter as much as the headline rate. Decide by running real tasks from your repository, counting passing test suites, and comparing cost per passing task.

Key takeaways:
- Headline input rates range from $0.30 to $4.00 per million tokens across these four models, and output from $1.20 to $20.00.
- Qwen3-Coder's rate depends on prompt length: a 200K-token prompt bills at three times the input rate and three times the output rate of a 20K-token one.
- Coding agents resend large contexts, so cached-input rates and context limits shape the bill as much as the base rate.
- Tool-calling and structured-output support is not published uniformly; confirm it for the exact model before building an agent on it.
- A passing test suite is the only outcome that counts. Compare cost per passing task on tasks from your own repository.

Coding is where model spend concentrates fastest. An agent that reads files, runs tests and edits code sends large prompts many times per task, and a team that adopts one sends thousands of tasks a week. Four models are positioned by their vendors for this work: Anthropic's Claude Opus 5.5, for long-running agentic coding and knowledge work[1]; Moonshot AI's Kimi K2.7 Code, described as Kimi's dedicated coding model[2]; Alibaba Cloud's Qwen3-Coder, served as `qwen3-coder-plus`[3]; and MiniMax M3, described by MiniMax as a frontier multimodal coding model[4].

This comparison uses only what those vendors publish, read on 2026-09-29, and leaves quality claims out. The method at the end is how to get the quality answer for your own codebase.

## List rates at the shortest prompt tier

[Diagram: Vendor list rates per million tokens at each model's lowest prompt-length tier, read 2026-09-29.]

- **Claude Opus 5.5:** $4 input and $20 output per million tokens, with cache hits at $0.20 (0.05x input)[5].
- **Kimi K2.7 Code:** $0.95 input on a cache miss, $0.19 on a cache hit, $4 output[6].
- **Qwen3-Coder** (`qwen3-coder-plus`, International deployment): $1 input and $5 output for prompts up to 32K tokens[3].
- **MiniMax M3:** $0.30 input and $1.20 output for prompts up to 512K tokens, with cache reads at $0.06; MiniMax labels this rate permanent[7].

The catalog entries INFRO estimates against are on the [Claude Opus 5.5](https://infro.io/models/anthropic/claude-opus-5.5), [Kimi K2.7 Code](https://infro.io/models/moonshot/kimi-k2.7-code), [Qwen3-Coder](https://infro.io/models/qwen/qwen3-coder) and [MiniMax M3](https://infro.io/models/minimax/minimax-m3) model pages.

## Prompt length changes the rate for two of them

Coding prompts are long. A repository map, several files, a failing test log and the conversation so far can pass 100K tokens quickly. Two of these models price by prompt length.

[Diagram: Published rates per million tokens by the number of input tokens in the request, read 2026-09-29.]

Alibaba Cloud prices `qwen3-coder-plus` in four tiers: up to 32K input tokens at $1 and $5, 32K–128K at $1.80 and $9, 128K–256K at $3 and $15, and 256K–1M at $6 and $60[3]. MiniMax prices M3 at $0.30 and $1.20 up to 512K input tokens and $0.60 and $2.40 above[7]. Anthropic bills Opus 5.5's full 1M window at the standard rate[5], and Moonshot lists one rate for Kimi K2.7 Code[6].

> **Example: One agent step at three prompt sizes**
> Illustrative arithmetic on published rates, no caching, 3,000 output tokens.
> 
> At 20K input tokens: Qwen3-Coder $0.02 + $0.015 = $0.035; Opus 5.5 $0.08 + $0.06 = $0.14.
> 
> At 150K input tokens: Qwen3-Coder $0.45 + $0.045 = $0.495; Opus 5.5 $0.60 + $0.06 = $0.66.
> 
> At 300K input tokens: Qwen3-Coder $1.80 + $0.18 = $1.98; Opus 5.5 $1.20 + $0.06 = $1.26.
> 
> The ordering flips as the prompt grows. With caching on, it moves again — which is why measured runs, not rate cards, decide.

## Context, output and tools

[Diagram: What each vendor's pages state, read 2026-09-29. "Not listed" means the pages loaded for this article did not state it, not that the model lacks it.]

- **Context.** Opus 5.5 has a 1M-token window and 128K output on the synchronous API, and up to 300K output on the Message Batches API with a beta header[1]. Moonshot lists a 262,144-token context for Kimi K2.7 Code[6]. MiniMax lists a 1M context for M3[4]. Alibaba Cloud's pricing for `qwen3-coder-plus` runs to 1M input tokens[3].
- **Tool calling.** Anthropic states all current Claude models support tool use[1]. Alibaba Cloud lists the Qwen3-Coder series among models that support function calling[8]. Moonshot documents tool calls on the Kimi API, using Kimi K3 and K2.6 in its examples[9]; the pages read did not list K2.7 Code specifically. MiniMax's pages read for this article did not state tool-calling support for M3.
- **Structured outputs.** Generally available on Opus 5.5[10]. Not stated for the other three on the pages read.
- **API shape.** Moonshot documents an OpenAI SDK integration against its own base URL[9], which matters for how you connect it.

For a coding agent, confirm tool-call support and the format of tool-call arguments on the exact model before anything else; a model that cannot call your tools reliably cannot run the agent, whatever its rate.

## What a coding comparison has to measure

Coding has an unusually good outcome signal: the tests. A patch that applies and turns the suite green is a success; anything else is not, however plausible it looks. That makes cost per passing task measurable, and it makes three things worth recording beyond the rate:

1. **Steps per task.** An agent that needs twelve model calls to finish costs roughly twelve times one call. Fewer, longer calls and more, shorter ones price differently under tiered rates.
2. **Prompt growth.** Agents accumulate context. Record input tokens per step, because a tiered rate applies per request.
3. **Cache hit rate.** Coding agents resend the same files. Opus 5.5 at $0.20 per million cached, Kimi K2.7 Code at $0.19 and MiniMax M3 at $0.06 make the cached share of each step significant[5][6][7].

## Fixed overheads in an agent loop

Every step of a coding agent carries tokens that are not your code: the system prompt, tool definitions, and whatever the provider adds when tools are present. Anthropic publishes its share: a request with tools on Opus 5.5 includes a 286-token tool-use system prompt, before your own tool names, descriptions and schemas[5]. A coding agent with a dozen tools, each with a JSON schema, can carry several thousand tokens of definitions on every step.

Those tokens are the same on every step, which makes them good candidates for caching — and makes the cached-input rate, not the base rate, the one that applies to them after the first call. When you compare models, structure the prompt so the stable part (system prompt, tool definitions, repository map) comes first and the changing part (the latest tool result, the current diff) comes last. A comparison run with an uncacheable prompt order measures a configuration you would not ship.

## Hosting, region and data questions

The rates above are each vendor's own hosted API. Moonshot documents its API at `api.moonshot.ai`[9]; the Qwen3-Coder rates are for Alibaba Cloud's International (Singapore) deployment[3]. Where a model's weights are published, other hosts may serve it at their own rates and with their own limits, and the same model name can behave differently on different hosts — see [running open-weight models in production](https://infro.io/blog/chinese-open-weight-models-guide-2026) for the questions to ask. Before a coding agent sends proprietary source code anywhere, confirm with your security team which hosts and regions are approved, and check each vendor's data-use terms for the account type you hold.

## A method for choosing

[Diagram: An evaluation loop for coding models: real tasks, identical conditions, a test suite as the judge, and cost joined to outcome.]

1. **Collect 30–100 real tasks** from your repository's history: closed issues with the commit that fixed them, and the tests that prove it.
2. **Fix the harness.** Same agent loop, same tools, same file-retrieval strategy, same step limit for every model. Change only the model.
3. **Run each task on each model**, apply the patch, run the tests, record pass or fail.
4. **Sum estimated provider cost per task** across every step, including failed runs.
5. **Divide total cost by passing tasks** per model, and look at pass rate and cost per pass together. A model with a lower cost per pass but a pass rate below your bar is still out.
6. **Route by task tier.** Small, well-scoped changes and large refactors may land on different models.

## Running a coding comparison through INFRO

Connect Anthropic directly as a [provider connection](https://infro.io/docs/providers). Moonshot, Alibaba Cloud and MiniMax have no dedicated connection kind; reach them through an OpenAI-compatible endpoint connection pointed at the vendor's own API, or through a host that serves the model, with a model map from the catalog id (`moonshot/kimi-k2.7-code`, `qwen/qwen3-coder`, `minimax/minimax-m3`) to the id that endpoint expects. Each vendor bills its own account directly.

Tag every step of an agent run with the reserved metadata keys, so the run can be costed as a whole:

```typescript
import OpenAI from "openai";

const client = new OpenAI({ apiKey: process.env.INFRO_API_KEY, baseURL: "https://api.infro.io/v1" });

export async function step(model: string, taskId: string, stepName: string, messages: OpenAI.ChatCompletionMessageParam[]) {
  const res = await client.chat.completions.create({
    model,
    messages,
    // @ts-expect-error INFRO extension field, forwarded as-is by the SDK
    metadata: { trace_id: `${model}:${taskId}`, workflow: "coding-eval", step: stepName },
  });
  return res;
}
```

After the tests run, `GET /v1/traces/{trace_id}` returns every request in that run in order, with estimated cost by step; `cost_is_partial` is set when any call in the run was unpriced, rather than the total being filled in ([request traces](https://infro.io/docs/observability/traces)). Join each trace's cost to the task's pass or fail in your harness, and `GET /v1/usage?group_by=workflow` or `group_by=model` gives the totals ([usage analytics](https://infro.io/docs/observability/analytics)).

One caution on estimates: the catalog carries one rate per model. Qwen3-Coder is estimated at its up-to-32K tier, so a longer prompt's estimate reads low; if your agent's prompts sit in a higher tier, enter your own rate under Prices ([billing](https://infro.io/docs/org/billing)) before comparing.

When the evaluation is done, a [route](https://infro.io/docs/routes) such as `code-agent` lists the chosen model first and a tested alternative second, and the agent sends the slug. A key can be pinned to that route so the coding tool cannot call other models directly ([routing](https://infro.io/docs/features/routing)).

## Questions

### Are Kimi, Qwen and MiniMax models open-weight?

Several models from these labs publish weights, but whether a specific API model does varies by model and version. Check the lab's model card and license for the exact model. The rates in this comparison are for each vendor's own hosted API; other hosts set their own.

## Sources

1. Models overview — Anthropic. https://platform.claude.com/docs/en/about-claude/models/overview (accessed 2026-09-29)
2. Models — Moonshot AI. https://platform.kimi.ai/docs/models (accessed 2026-09-29)
3. Model pricing — Alibaba Cloud Model Studio. https://www.alibabacloud.com/help/en/model-studio/model-pricing (accessed 2026-09-29)
4. Models — MiniMax. https://platform.minimax.io/docs/guides/models-intro (accessed 2026-09-29)
5. Pricing — Anthropic. https://platform.claude.com/docs/en/about-claude/pricing (accessed 2026-09-29)
6. Chat model pricing — Moonshot AI. https://platform.kimi.ai/docs/pricing/chat (accessed 2026-09-29)
7. Pay-as-you-go pricing — MiniMax. https://platform.minimax.io/docs/guides/pricing-paygo (accessed 2026-09-29)
8. Function calling — Alibaba Cloud Model Studio. https://www.alibabacloud.com/help/en/model-studio/qwen-function-calling (accessed 2026-09-29)
9. Use the Kimi API to complete tool calls — Moonshot AI. https://platform.kimi.ai/docs/guide/use-kimi-api-to-complete-tool-calls (accessed 2026-09-29)
10. Structured outputs — Anthropic. https://platform.claude.com/docs/en/build-with-claude/structured-outputs (accessed 2026-09-29)