Copilot's model picker got its first open-weight row on July 1: Kimi K2.7 Code, Moonshot AI's coding model, billed at the lowest tier in the roster. Selecting it takes one click. Getting real value out of it takes a routing habit and — the part most people skip — a tested fallback. Here's all three.

1. Turn it on#

If you're on Copilot Pro, Pro+, or Max, it's already there. Open the Copilot chat or agent panel, click the model name at the top of the input box, and pick Kimi K2.7 Code from the list. Done.

If you're on Copilot Business or Enterprise, a member picking it will find it greyed out until an admin enables the model:

Organization Settings → Copilot → Policies → Models
  → enable "Kimi K2.7 Code"

(Enterprise admins do the same one level up, under Enterprise → Policies.) The toggle is per-org, so you can pilot it with one team before rolling it out. Once it's on, it shows up in every member's picker across VS Code (1.127.0+), Visual Studio, JetBrains, Xcode, Eclipse, the Copilot CLI, github.com, and mobile.

2. Route by task, not by loyalty#

The mistake is treating the picker as a single global choice — "we're a Kimi shop now." The win is switching per task. Kimi is cheap and fast; a frontier model is expensive and, on the hard problems, worth it. Match the model to the job:

Cheap models aren't for when you don't care about quality. They're for the large fraction of coding work where the answer isn't in doubt — only the typing is.

3. The cost math#

Kimi K2.7 Code lists around $0.95 per million input tokens and $4.00 per million output, versus roughly $3 / $15 for a frontier tier. That's about a 3x cut on input and 3–4x on output. Inside Copilot you don't see two invoices — it's metered at provider list pricing out of your AI-credit allotment, so the saving shows up as your credits lasting three-ish times longer on the work you route to it.

One lever most people miss: Kimi's cache-hit input price drops to about $0.19 per million. If your agent re-sends a large stable context (a system prompt, a repo map, a spec) across many calls, you're paying the cache-hit rate on the repeated part — so structuring prompts so the fixed context comes first is a real discount, not a micro-optimization.

4. Make the fallback real#

Here's the part that turns "a cheaper option" into leverage: Kimi's weights are open, so you can run the identical model off Copilot entirely. The point isn't to leave GitHub today — it's to have a floor under your cost that no repricing can lift. But a fallback you've never exercised is a rumor. Stand it up once.

The fast path is Ollama:

ollama pull kimi-k2.7-code
ollama serve            # OpenAI-compatible API on http://localhost:11434

Then point any CLI coding agent at it — it already speaks /v1/chat/completions:

export OPENAI_BASE_URL=http://localhost:11434/v1
export OPENAI_API_KEY=ollama          # any non-empty string
export OPENAI_MODEL=kimi-k2.7-code
your-agent --model kimi-k2.7-code

For a team, serve the same weights on vLLM or SGLang behind that same OpenAI-compatible endpoint in your own VPC — real GPUs required, since it's a 1T-parameter MoE, so this is a team lever, not a laptop trick. Either way, keep a small eval set — a handful of representative tasks with known-good outcomes — and run it against Copilot's Kimi, your self-hosted Kimi, and a frontier model. When behavior drifts, you'll see it. When Copilot's pricing changes, your migration is a config flip you've already tested, not a fire drill.

That's the whole play: enable it in a click, route the bulk of your work to it, keep the hard problems on a frontier model, and prove out the self-host path once so the cheap row is also the safe one.