Kimi K2.7 Code on Mac: Cloud, API, or GGUF?

As of August 15, 2026. Kimi K2.7 Code is a coding-agent model from Moonshot AI. You can operate it from several Mac interfaces, but an interface does not automatically make inference local. A useful decision requires separating five paths: the Ollama cloud tag, the separate Kimi Code product, the direct Kimi API, providers such as OpenRouter, and a very large third-party GGUF.

The short decision

• Quick Mac evaluation: kimi-k2.7-code:cloud in Ollama is the simplest route if cloud processing is acceptable.
• Product integration: the direct Kimi API provides OpenAI- and Anthropic-compatible interfaces and uses the model name kimi-k2.7-code.
• Kimi Code CLI: the product has its own model IDs, membership plans and quotas. Its prices are not automatically API token prices.
• Offline Apple Silicon: do not treat it as a normal Mac setup. Third-party GGUF documentation does describe Metal support, but lists roughly 310–605 GB of total memory depending on quantization.
• Privacy: cloud paths send code, prompts and any included files away from the Mac under the selected provider’s terms.

No original Apple Silicon speed test is included. The local assessment therefore separates documented prerequisites from theoretical feasibility.

What “on a Mac” actually means

Access path	What runs locally?	Where inference runs	Context in the current source
Ollama :cloud	Ollama, terminal or agent client	Ollama Cloud	256K; text and image
Kimi Code	CLI/IDE and local session control	Kimi service	K2.7 Code: 256K
Kimi API	your SDK, terminal or server	Kimi API	256K; text, image and video in the official API
OpenRouter	your client	selected routing provider	check provider metadata; currently 262K shown
GGUF with llama.cpp/Unsloth	runtime and weights	your Mac, if memory is sufficient	depends on runtime and configured context

“Kimi on Mac” therefore often describes the operating location of the client. Only the last row is a local inference path—and it also requires a very large third-party package.

Model facts from the model card

Moonshot publishes Kimi K2.7 Code as a mixture-of-experts model with:

• 1 trillion total parameters and 32 billion activated parameters per token;
• 384 experts, with eight selected per token plus a shared expert;
• 61 layers and MLA attention;
• a 256K context length;
• a MoonViT vision encoder with 400 million parameters;
• native INT4 quantization;
• image and video input in the official API.

“32B active” does not mean that a 32B model is loaded into memory. The weights, runtime, activations and KV cache still matter. The official model card recommends Transformers, vLLM and SGLang; it does not present a convenient standard workflow for an ordinary Mac.

Ollama Cloud: the straightforward Mac route

Ollama currently lists a cloud tag:

ollama launch claude --model kimi-k2.7-code:cloud

The Ollama page also lists integrations for OpenCode, Hermes Agent and OpenClaw. The client starts on the Mac, but the :cloud suffix is the important part: it signals remote inference. The current tag shows a 256K context window and text/image input.

Check availability, quotas and billing directly with Ollama before production use. Those details can change independently of the model version. ollama run or ollama launch is not evidence that several hundred gigabytes of model weights are stored locally.

Kimi Code is a separate product

Kimi Code and the Kimi API are not the same billing layer:

• The API platform uses the model name kimi-k2.7-code and pay-as-you-go billing.
• Kimi Code uses product IDs such as kimi-for-coding and its own membership quotas.
• The API HighSpeed variant is kimi-k2.7-code-highspeed; the corresponding Kimi Code product ID is kimi-for-coding-highspeed.
• K2.7 Code remains a 256K model in both variants. HighSpeed changes output speed, not the model class or context window.

Always compare the model ID, product, plan and billing method. A Kimi Code membership price must not be presented as an API token price.

Direct Kimi API: current prices and fixed parameters

At the audit date, the official Kimi platform showed these prices per one million tokens; applicable taxes were not included:

Cost type	Kimi API, checked August 15, 2026
Cache-hit input	$0.19
Input	$0.95
Output	$4.00

Prices are provider- and date-dependent. During the same audit, OpenRouter showed $0.67 input, $3.40 output and a 262K context field. That is provider metadata, not a correction to the official Kimi model documentation. OpenRouter also explains that different companies host the model and that routing modes influence provider selection.

For API and Claude Code integrations, the model rules matter more than a short example call:

• thinking is always enabled; disabling it causes an error according to Kimi;
• preserved thinking stays enabled and must be retained across multi-step tool calls;
• temperature is fixed at 1.0 and top_p at 0.95; other values can fail;
• n, presence penalties and frequency penalties are fixed as well;
• the documented default for max_tokens is 32K;
• the model card says video is limited for third-party deployments and currently officially supported through the Kimi API.

K2.7 Code is therefore a specialized agent model, not a freely tunable chat model.

Local GGUF inference: possible, but not a normal Mac setup

Moonshot’s deployment guide shows server paths using vLLM or SGLang, including an H200 node with tensor parallelism 8. That is a server reference, not an Apple Silicon guide.

Independent Unsloth documentation additionally describes GGUF quantizations for llama.cpp and Unsloth Studio, including Metal builds for Apple Macs. Its approximate total-memory figures are:

Quantization	Documented total requirement
Dynamic 1-bit	about 310 GB
Dynamic 2-bit	about 325–350 GB
Dynamic Q3	about 385–470 GB
Q8, described as near-lossless	about 605 GB

These are not Mac benchmarks measured by ai-on-mac.com. They come from a third-party guide and refer to a specific GGUF/runtime combination. A Mac Studio with very large Unified Memory may theoretically enter this class; for typical 16-, 24-, 32-, 64- or 128-GB Macs, the published sizes do not support a normal recommendation. Even with enough memory, speed, context length, Metal support and image/video behavior must be tested separately.

“Open weights” therefore does not mean “suitable for every Mac.” The model card and license make local use possible, but the practical hardware threshold remains unusually high.

Read the benchmarks correctly

The model card publishes figures including:

Benchmark	Kimi K2.7 Code	GPT-5.5	Claude Opus 4.8
Kimi Code Bench v2	62.0	69.0	67.4
Program Bench	53.6	69.1	63.8
MCP Mark Verified	81.1	92.9	76.4

These are vendor-published model-card figures, not an independent leaderboard. The tables use different agent harnesses and do not automatically transfer to your repository. The defensible conclusion is narrower: Moonshot reports an improvement over K2.6, and K2.7 Code is strong on selected agentic tables; that is not a general win against every frontier model.

Privacy and a safer evaluation

With Ollama Cloud, Kimi Code, the Kimi API and OpenRouter, submitted prompts leave the Mac. A coding agent may also transmit file contents, diff context, tool output or images. For an evaluation:

1. use a separate non-production repository;
2. do not copy keys, cookies, customer data or production files into it;
3. restrict the files and shell commands the agent can access;
4. review changes as a diff before applying them;
5. measure cost, latency, tool failures and abort behavior on your own tasks;
6. recheck the provider, model ID and quotas after the test.

The weights use a Modified MIT License. In addition to the usual MIT conditions, it includes an attribution requirement for very large commercial products or services (more than 100 million monthly active users or more than $20 million in monthly revenue). The full license text controls any commercial use.

Practical Mac recommendation

Kimi K2.7 Code is most useful on a Mac as a cloud coding agent. Ollama Cloud is the easiest entry point; Kimi Code and the direct API are separate products with different IDs, quotas and prices. OpenRouter is another provider with its own metadata.

A local GGUF route is not imaginary, but it belongs in the category theoretically possible on very large hardware, not “install it on a Mac and start coding.” If you need offline operation or strict on-device data residency, choose a much smaller model with a concrete Apple Silicon workflow.

Sources

• Kimi API: Model List — official IDs and 256K context.
• Kimi API: K2.7 Code — capabilities, modalities and API rules.
• Kimi API: K2.7 Code pricing — official price page and billing notes.
• Kimi API: Model Parameter Reference — fixed parameters and HighSpeed distinction.
• Moonshot AI: Kimi-K2.7-Code on Hugging Face — model card, benchmarks, deployment and license reference.
• Moonshot AI: deployment guide — vLLM/SGLang server examples.
• Moonshot AI: Modified MIT license — complete license terms.
• Ollama: Kimi K2.7 Code and tags — current cloud tag and integrations.
• Kimi Code: model configuration — product IDs, plans and quotas.
• Unsloth: run Kimi K2.7 Code locally — independent GGUF/memory figures; not a benchmark measured by ai-on-mac.com.
• OpenRouter: Kimi K2.7 Code — provider-specific metadata and routing note.