Kimi K2.7 Code costs $0.95/M in GitHub Copilot and loses 6 of 6 benchmarks to GPT-5.5

Summary. GitHub made Kimi K2.7 Code generally available in Copilot on 1 July 2026, calling it "the first open-weight model offered as a selectable option in the Copilot model picker". It bills at $0.95 per 1M input tokens, $0.19 cached and $4.00 output, which makes it the cheapest Versatile model GitHub lists apart from its own Raptor mini. GPT-5.5 costs $5.00 and $30.00 for the same two columns, so Kimi is 5.3x cheaper on input and 7.5x cheaper on output. Then read Moonshot AI's own model card: across all six benchmarks it publishes, Kimi K2.7 Code scores below GPT-5.5, and below Claude Opus 4.8 on five of the six. It is off by default for Copilot Business and Enterprise, and an admin has to turn it on.

So the decision is not "is this model good". It is "is a 5x discount worth a measurable capability gap on the specific work my team does", and that answer differs by team.

What GitHub actually shipped

The changelog entry from 1 July 2026 is short and worth reading closely, because three of its sentences carry the whole decision.

First, availability: "Kimi K2.7 Code, an open-weight model, is now generally available in GitHub Copilot. This is the first open-weight model offered as a selectable option in the Copilot model picker, giving you more choice and a lower-cost option for your coding workflows."

Second, hosting: "Kimi K2.7 Code is hosted by GitHub on Microsoft Azure." The weights are Moonshot's; the inference is not. Your tokens go to Azure, not to a Beijing endpoint, and that distinction is the first thing your security reviewer will ask about.

Third, the gate: "Kimi K2.7 Code is off by default for Copilot Business and Copilot Enterprise. Plan administrators must enable the Kimi K2.7 Code policy in Copilot settings before anyone in their organization can select it. If the policy is left off, the model stays unavailable to that organization."

GitHub then adds its own advice, which is unusually direct for a changelog: "We recommend administrators review open-weight models against their own security, compliance, and data-governance requirements before enabling them."

Rollout began with Copilot Pro, Pro+ and Max plans, with Business and Enterprise "over the coming weeks". The surfaces are broad: Visual Studio Code 1.127.0 or later, Visual Studio 17.14.6 or later, Copilot CLI, the GitHub Copilot cloud agent, the GitHub Copilot App, github.com, GitHub Mobile on iOS and Android, JetBrains 1.9.1-251 or later, Xcode and Eclipse.

The price, in the only units that matter

Copilot bills tokens, not seats, for model usage. GitHub's pricing reference states the mechanics plainly: "When you use Copilot, the interaction consumes tokens: input tokens (what's sent to the model), output tokens (what the model generates), and cached tokens (context the model reuses or stores). Each token is priced based on the model used, and the total is converted into AI credits, where 1 AI credit = $0.01 USD."

One useful exclusion: "Code completions and next edit suggestions are not billed in AI credits. They remain unlimited for all paid Copilot plans and continue to use their existing counting mechanism." The tab-complete your developers use all day is not what generates the bill. Agent runs are.

Here is where Kimi K2.7 Code sits against the models a Copilot team actually chooses between. All figures are per 1M tokens, from GitHub's published pricing tables as of 17 July 2026.

Two footnotes on that table matter. Claude Sonnet 5's rate is temporary: GitHub states it "is available at the promotional pricing of $2.00 per 1M input tokens, $0.20 per 1M cached input tokens, $2.50 per 1M cache write tokens, and $10.00 per 1M output tokens through August 31, 2026." And Anthropic models carry a cache write cost that the others do not, $6.25 per 1M for Opus 4.8.

Against GPT-5.5, Kimi is 5.3x cheaper on input and 7.5x cheaper on output. Against Claude Sonnet 5 at its promotional rate, 2.1x and 2.5x. Against GPT-5.6 Terra, 2.6x and 3.75x. Those are large enough gaps that "just use the frontier model" stops being an obvious call for high-volume, low-stakes work.

The benchmark table Moonshot published itself

This is the part the coverage largely skipped. Moonshot AI's model card for Kimi-K2.7-Code carries an evaluation table with four columns: Kimi K2.6, Kimi K2.7 Code, GPT-5.5 and Claude Opus 4.8. These are the vendor's own numbers, chosen by the vendor, published by the vendor.

Six rows, six losses to GPT-5.5. Against Claude Opus 4.8, Kimi wins exactly one row, MCP Mark Verified at 81.1 against 76.4. On its own in-house coding benchmark, the one named after itself, it trails both frontier models.

The generational gain is real: K2.7 Code improves on Kimi K2.6 across every row, from 50.9 to 62.0 on Kimi Code Bench v2 and from 26.7 to 35.1 on MLS Bench Lite. Moonshot also reports better token economy, "reducing thinking-token usage by approximately 30% compared with Kimi K2.6". This is a better open-weight model than the one before it. It is not a frontier model wearing a discount.

Three caveats belong on that table, and Moonshot states all three itself. Kimi Code Bench v2 and Kimi Claw 24/7 Bench are described on the card as in-house benchmarks. MCP Mark Verified is a human-verified edition that the card says "will be open-sourced soon", so it is not independently reproducible today. And the test conditions were not identical: "Kimi K2.7 Code and K2.6 were tested with thinking mode enabled via Kimi Code CLI at temperature = 1.0, top-p = 0.95, and a 262,144-token context length; GPT-5.5 ran in Codex with xhigh mode, and Opus 4.8 in Claude Code with xhigh mode."

Read that last one twice before you use these numbers to justify anything. Each model was run inside its own vendor's agent harness. You are comparing model-plus-harness, not model to model, and in Copilot none of the three runs in the harness it was benchmarked in. Our note on running AI agent evals in CI so failures are not silent applies directly here: the only benchmark that settles this for your team is your own repository.

The catch nobody prices in: thinking is billed

Here are two facts from the model card that engineering leads should put side by side.

Fact one: "Note that Kimi-K2.7-Code forces thinking and preserve_thinking as True." The card is explicit that this cannot be turned off: "Instant mode is not supported", and on preserve_thinking, "This feature is enabled by default and can't be disabled." Preserve thinking "retains full reasoning content across multi-turn interactions".

Fact two: Copilot bills output tokens at $4.00 per 1M, and reasoning tokens are output tokens.

A model that always thinks, and that carries its full reasoning forward across every turn of a multi-turn agent session, does not consume tokens the way a sticker price suggests. The 30% thinking-token reduction against K2.6 is Moonshot telling you this was a problem worth fixing. The honest read is that the effective discount against GPT-5.5 is somewhere below 7.5x on output, and you cannot know where without measuring your own traffic. Anyone who quotes you a clean multiple has not run the workload.

The architecture explains why the sticker is low in the first place. From the card: 1T total parameters with 32B activated per token, 384 experts with 8 selected per token, one shared expert, 61 layers, MLA attention, a 160K vocabulary, a 256K context length, and a 400M-parameter MoonViT vision encoder. A mixture-of-experts model activates a small slice of itself per token, so it serves at roughly the cost of a 32B dense model while holding the knowledge of something far larger. That is the whole economic argument for open-weight MoE coders, and it is the same argument we worked through in our GLM-5.2 self-host versus API analysis.

Who should turn it on, and who should not

The pattern that works is not picking a winner. It is routing: cheap model for mechanical work, frontier model for the hard 10%, measured at the boundary. We set that argument out in full in our hybrid LLM routing decision framework, and Copilot's model picker plus per-model billing is the first time most teams can implement it without building anything.

What your security review will actually ask

GitHub told administrators to run this review, so run it properly rather than reflexively. Four questions cover most of it.

Where does inference run? On Microsoft Azure, hosted by GitHub, per the changelog. This is the answer that resolves most concerns, and it is worth putting in the ticket verbatim rather than paraphrasing.

What is the licence? Modified MIT, covering both the code repository and the weights. That is unusually permissive for a 1T-parameter model, and it is why self-hosting is a live option rather than a hypothetical.

What leaves the building? The same thing that leaves it for GPT-5.6 or Claude: your prompt context. The model's provenance does not change the data flow when GitHub hosts it on Azure. If your policy already permits Copilot with a US frontier model, the incremental data-governance question here is narrower than it first appears, though "narrower" is not "none", and your subprocessor list may still name specific model providers.

Who can turn it on? For Business and Enterprise, only a plan administrator, through the Copilot settings policy. If the policy is off, no one in the organisation can select it. That default is a gift: it means you can take this decision deliberately rather than discovering the model in your token bill. Teams working through vendor and export-control questions on model choice will find our enterprise AI export control compliance playbook covers the adjacent ground.

India-specific considerations

For teams in India, three things shift the maths.

Copilot bills in USD and converts token usage into AI credits at 1 credit = $0.01. A rupee cost base with a dollar tool bill means model choice is a foreign-exchange decision as much as an engineering one, and a 5.3x input discount lands harder on a Gurugram P&L than on a San Francisco one. We covered the same dynamic for a different vendor in our analysis of Claude's rupee pricing against US teams.

Service businesses have a second constraint that product companies do not: the client's approved-vendor list. If you build for a regulated client, the model your developers select inside Copilot may fall under a contract clause about subprocessors and data handling. The right sequence is to ask the client before enabling the policy, not after an auditor finds it. Under the Digital Personal Data Protection Act 2023, the accountability for personal data in your prompts stays with you regardless of which model processed it.

Third, headcount economics cut against the reflex to cheap out. In a market where senior engineering time is the scarce input, a model that finishes 53.6 out of 100 on Program Bench against GPT-5.5's 69.1 is not saving money if a senior engineer spends an extra hour untangling the difference. Run the discount against loaded cost per hour, not against the token line alone.

How to decide in one week

1. Turn the policy on for a single team, not the organisation. It is off by default; keep that property while you learn.

1. Pick 20 real tasks from your backlog, split them into mechanical and hard, and run both models on both piles.

1. Measure tokens, not vibes. Output tokens especially, because thinking is forced on and preserved across turns.

1. Compare against the loaded hourly cost of the engineer reviewing the output, not against $4.00 per 1M.

1. Decide per work type, not per team. The answer is almost always "both, routed".

1. Re-check in September. Claude Sonnet 5's promotional pricing ends on 31 August 2026, which moves the nearest comparison point.

Step 6 is the one teams forget. The price list under this decision is not stable, and a routing rule written in July against a promotional rate is a routing rule that quietly becomes wrong in September.

FAQ

How eCorpIT can help

eCorpIT is a CMMI Level 5 certified engineering organisation in Gurugram, and our senior-led teams have spent 2026 helping engineering leads answer exactly this question with numbers instead of opinions. We instrument Copilot token spend by work type, run a controlled bake-off on your repository rather than someone else's benchmark, and write the routing rule that follows from the result. Where a client contract or DPDP obligation constrains model choice, we get that answered before the policy is enabled, not after. Talk to us about your Copilot rollout.

References

1. Kimi K2.7 Code is generally available in GitHub Copilot — GitHub Changelog, 1 July 2026.

1. Models and pricing for GitHub Copilot — GitHub Docs, retrieved 17 July 2026.

1. moonshotai/Kimi-K2.7-Code model card — Moonshot AI on Hugging Face.

1. Model multipliers for annual plans on request-based billing (legacy) — GitHub Docs.

1. GitHub Copilot is moving to usage-based billing — The GitHub Blog.

1. Supported AI models in GitHub Copilot — GitHub Docs.

1. Choosing the right AI model for your task — GitHub Docs.

1. Kimi K2.7 Code API pricing and benchmarks — OpenRouter.

1. Kimi K2.7 Code benchmarks, pricing and size — LLM Stats.

1. Moonshot AI releases Kimi K2.7 Code, an open 1T MoE coder — AI Weekly.

1. Kimi K2.7 Code: open-source agentic coding model — Moonshot AI.

Last updated: 17 July 2026.