Xcode Now Supports Kimi K3 — The Complete Beginner's Guide

Once Kimi K3 shipped, a lot of Apple-ecosystem developers had the same first thought: "can I just use this in Xcode?" The answer is yes — and there's more than one way to do it. This is a purely hands-on, step-by-step guide with no theory detour: three real integration paths, in order — Xcode's built-in custom Model Provider (zero third-party tools, the simplest option), OpenCode (official built-in Moonshot AI auth, plus the Xcode 27 MCP bridge that lets the agent actually operate on your project), and the third-party open-source tool CC Switch (a local router + protocol converter, best if you're juggling multiple CLIs and multiple models). Every method comes with copy-pasteable steps, the actual field names, and known gotchas. There's also a section for readers outside the US who can't reach Moonshot's official endpoint smoothly — all three methods can be pointed at an AI relay provider's endpoint instead, with no other changes needed.

1. Why bother wiring Kimi K3 into Xcode

Moonshot AI shipped Kimi K3 on July 16, 2026 — 2.8 trillion parameters, which the company calls "the world's first 3T-class open-weight frontier model," with a context window of 1,048,576 tokens (roughly 1M) — one of the longest available to Apple-ecosystem developers right now. Demand spiked six-fold within 48 hours of launch, forcing Moonshot to temporarily pause new-user signups just to keep service quality for existing paying users — a decent signal that the coding capability actually holds up under real load, not just on a leaderboard.

For anyone writing Swift/SwiftUI/UIKit, a few things about Kimi K3 stand out: the 1M-token context window means you can hand it an entire mid-to-large module, or several files at once, instead of chopping things into pieces the way you'd have to with a shorter-context model; its always-on "thinking mode" (tunable via reasoning_effort across low/high/max) tends to be steadier than "one-shot" models on complex refactors or untangling multi-file dependencies; and it's an already-shipped, generally-available API — not a preview — so pricing, benchmarks, and stability are all things you can actually verify instead of betting on something still in beta.

Xcode doesn't know Kimi K3 out of the box, though — it ships wired to Apple's own Apple Intelligence and a short list of "officially recognized" big-name models. To actually use Kimi K3, you need one of the three paths below to feed it into Xcode's Coding Intelligence feature. None of the three is strictly better than the others — they fit different use cases. The next section gives you the short version, then we walk through each one in full.

Some context on why this is worth the ten minutes: multiple outlets report Moonshot's June annualized revenue (ARR) at roughly $300M, a valuation that briefly topped $20B, an ongoing funding round, and a Hong Kong IPO in progress. None of that tells you whether the model writes good Swift, but it does suggest this isn't a "ship and disappear" release — updates and ecosystem integrations (Xcode, OpenCode, various IDE plugins) are likely to keep coming, which makes wiring it up now a reasonably safe bet.

2. TL;DR: which method should you pick

The three methods solve different problems — here's a table laying out the trade-offs before we dive into each one:

If you just want to start chatting with Kimi K3 in Xcode as fast as possible, jump to Method 1 — five minutes and you're done. If you care more about agentic autonomy (editing files, running builds, reading diagnostics for you), see Method 2. If Xcode isn't your only tool and you've got Claude Code, Codex, and others to manage providers for, see Method 3.

3. Prep work: getting a Kimi K3 API key

All three methods need the same key — an API key from Moonshot AI's official open platform. Get this done first:

1. Go to platform.kimi.ai (Kimi Open Platform) and sign up / log in
2. Your account needs at least a $1 top-up before a key will actually work (calls fail once the free tier is used up or the balance hits zero)
3. Create a new API key in the console and save it somewhere safe — it's only shown in full once

Two things worth writing down, since you'll reuse them across every method below:

• API Base URL: https://api.moonshot.ai/v1 (an OpenAI-compatible Chat Completions endpoint)
• Model identifier: kimi-k3 (must be exactly these characters — not kimi-k3-chat, which will 404)

4. Method 1: Xcode's native custom Model Provider (simplest, zero third-party tools)

Xcode 26/27's Coding Intelligence feature lets you add any custom model provider that speaks an OpenAI-compatible format (or Claude's format), with no extra software required. This is the most direct of the three paths.

Step 1: Open Intelligence settings

Open Xcode, press ⌘, to get to Settings, and switch to the Intelligence tab. The exact label can vary slightly by Xcode version (some call it "Intelligence," others "Intelligence Mode"), but it's always somewhere in Settings.

Step 2: Add a Model Provider

Click "Add a Model Provider…" (on some newer builds this button reads "Add a Chat Provider" — the wording shifts across Xcode releases, but it lives in the same place). In the type picker that pops up, choose "Internet Hosted" (as opposed to "Locally Hosted," which is for locally-run models like Ollama).

Step 3: Fill in the connection details

You'll see a handful of fields — here's exactly what goes in each:

Step 4: Pick the model

Once the provider is saved, Xcode tries to pull its list of available models. If Kimi K3 doesn't show up automatically, type the model name in manually — it must be exactly kimi-k3. The common mistake is typing kimi-k3-chat, which doesn't exist and will 404.

Step 5: Verify the connection

Open any project, switch to Xcode's Agent mode (or the Coding Intelligence chat panel), set Kimi K3 as the active model, and start with something simple ("introduce yourself in one sentence") to confirm the wiring works — then try something real: select an existing View file and ask it to "explain this SwiftUI code's data flow and flag any potential retain-cycle risk," and check whether the response actually understood the project context and gave concrete, actionable advice. If both work, you're set. If something errors out, jump straight to section 8 for troubleshooting.

What's actually happening here: Xcode sends your editor-side chat requests straight to Moonshot's official endpoint in OpenAI Chat Completions format, with no proxy or conversion layer in between — the shortest possible path, the lowest latency, and the method least likely to break. The trade-off is that it's chat-only: Xcode sends the currently open file's contents along as context, but it can't have the model actually create or edit multiple files, or run a build to check diagnostics, the way Method 2's MCP hookup can. For day-to-day coding questions and code snippets, this is already more than enough.

5. Method 2: OpenCode (built-in Moonshot AI auth + the Xcode 27 MCP bridge)

OpenCode is an open-source coding agent that runs in your terminal, with official built-in Moonshot AI authentication — no manual base-URL entry required. Going further, Moonshot's own documentation confirms a more agentic setup: bridge OpenCode (running on Kimi K3) directly into your Xcode project via Xcode 27's MCP (Model Context Protocol) support, giving it the ability to read/write files, pull live compile diagnostics, run the Swift REPL, and drive SwiftUI previews — not just chat.

Step 1: Install OpenCode

On macOS, Homebrew is the easiest route:

brew install opencode-ai/tap/opencode

Or via npm (cross-platform, needs Node.js 18+):

npm install -g @opencode-ai/opencode

Step 2: Authenticate with Moonshot AI

Once installed, run the auth command in your terminal:

opencode auth login

From the provider list, choose "Moonshot AI", paste the API key from section 3, and confirm. No manual base-URL entry needed — OpenCode ships with Moonshot's config baked in.

Step 3: Select the Kimi K3 model

After launching OpenCode, use the built-in command to switch models:

/models

Pick Kimi K3 from the list. From here, every chat, code generation, and agent action inside OpenCode runs on Kimi K3.

Step 4 (advanced): Bridging into Xcode 27 via MCP

If you just wanted a standalone OpenCode chat, Step 3 already got you there. But the setup Moonshot's own docs specifically call out is letting OpenCode operate directly on the project you have open in Xcode — which needs Xcode 27's added MCP (Model Context Protocol) support:

1. Open Xcode's Settings (⌘,) → Intelligence, find the Model Context Protocol option, and enable it (on some builds the label reads "Enable Model Context Protocol")
2. Xcode's command-line tools ship with a binary called mcpbridge, which translates standard MCP protocol requests into Xcode's internal XPC calls — the same mechanism Apple uses to give external agents like Claude Code and Codex access to your project
3. Register OpenCode as a client that connects to this MCP bridge. Apple's official registration command for Claude Code is claude mcp add --transport stdio xcode -- xcrun mcpbridge; OpenCode uses a standard mcp config field — add a block like the one below to your project root (or ~/.opencode.json) to register xcrun mcpbridge as a local MCP server
4. Xcode needs to stay running with a project actually open — mcpbridge connects over XPC to a live Xcode process, so headless environments (like CI) can't use this path

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "xcode": {
      "type": "local",
      "command": ["xcrun", "mcpbridge"],
      "enabled": true
    }
  }
}

Save this .opencode.json (or the global ~/.opencode.json) and restart OpenCode — it'll automatically launch xcrun mcpbridge as a local process and connect. Confirm the exact field names against OpenCode's current MCP config docs, but the overall shape — a top-level mcp field, type: "local", and a command array — is the standard pattern OpenCode uses for local MCP servers.

Tip: tune reasoning_effort to the task

Kimi K3's thinking mode can't be fully turned off, but you can dial its strength via reasoning_effort across low / high / max. For small day-to-day edits, comments, or filling in unit tests, low is plenty fast; for multi-file dependency untangling, architecture-level refactors, or gnarly bug hunts — tasks that need real thought before acting — switch to high or max. It'll take longer, but the output is usually more reliable. In OpenCode you can adjust this per session without touching the config file.

6. Method 3: CC Switch (third-party local router, best for multi-tool setups)

CC Switch (GitHub: farion1231/cc-switch) is an open-source, cross-platform desktop app originally built to unify provider configuration across Claude Code, Codex, Gemini CLI, OpenCode, and other AI coding CLIs. Its core mechanism is a local HTTP proxy (listening by default on 127.0.0.1:15721) that exposes a uniform OpenAI-compatible Chat Completions interface externally, while doing the actual protocol conversion and routing internally.

Step 1: Install CC Switch

On macOS, Homebrew is recommended (supports auto-updates):

brew tap farion1231/ccswitch
brew install --cask cc-switch

Windows users can grab the .msi installer from GitHub Releases; Linux users can pick .deb/.rpm/AUR/.AppImage depending on their distro. You can also go straight to ccswitch.io or the GitHub repo for the right build.

Step 2: Add a Kimi K3 provider

1. Open CC Switch and click the "+" in the top right to add a new provider
2. If a preset like "Kimi For Coding" exists in the list, pick it directly; otherwise choose "Custom Provider" and manually enter https://api.moonshot.ai/v1 as the base URL and kimi-k3 as the model name
3. Paste your Moonshot API key
4. In Advanced Settings, confirm these: Upstream format set to Chat Completions (routing required); Context window set to 1048576; enable both Supports thinking mode and Supports reasoning effort (matching Kimi K3's always-on thinking mode and its reasoning_effort parameter)

That "routing required" flag matters: tools like Codex CLI speak the OpenAI Responses API protocol, while Kimi Open Platform exposes a standard OpenAI-compatible Chat Completions API — two different protocols. CC Switch's Local Routing feature is what converts requests and streamed responses between them in real time, which is exactly why this third method needs its own dedicated local router process instead of connecting directly the way Method 1 does.

Step 3: Turn on Local Routing

1. Go to CC Switch's Settings and flip the Routing master switch to start the local service (default address 127.0.0.1:15721)
2. In the Routing Enabled list, check the target tool you want to route (e.g. Codex)
3. Click "Health Check" on the Kimi K3 entry you just configured — CC Switch fires a test request to confirm the key and endpoint actually work, so you're not debugging a broken config from inside Xcode later

The whole point of CC Switch is turning "N CLIs, each with its own config file, each pointed at a different provider" into "one screen that manages all of it." If Xcode is the only tool you use, Method 1 is already sufficient and installing a whole desktop app just for this one case is overkill; but if you're also running Claude Code or Codex on other projects, CC Switch lets you keep Kimi K3, DeepSeek, GLM, and every relay provider's keys in one place, making switching and troubleshooting a lot less painful — which is the main reason it keeps getting recommended in developer communities.

Step 4: Point Xcode at CC Switch's local router (optional)

CC Switch is primarily built for command-line tools like Codex CLI and Claude Code — it doesn't ship a dedicated "Xcode Provider" option out of the box. But because what it exposes externally is just a standard OpenAI-compatible Chat Completions endpoint, you can take Xcode's custom-provider setup from Method 1 and swap the URL from Moonshot's official address to CC Switch's local one instead:

URL: http://127.0.0.1:15721
API Key Header: Authorization
API Key: (whatever that provider entry in CC Switch requires — often any placeholder string works, since the real authentication already happened inside CC Switch)

With this in place, Xcode's requests actually hit the local CC Switch gateway on your machine, which then forwards them to Kimi K3 — the upside being you can do provider switching, failover, and relay-preset management all from CC Switch, instead of editing Xcode's config back and forth.

7. Note for readers outside the US: swapping in a relay endpoint

If reaching Moonshot's official international endpoint directly isn't reliable from where you are, all three methods above only ever need "an OpenAI-compatible base URL plus an API key" — swapping that out is straightforward:

• Method 1 (Xcode native Provider): change the URL to your AI relay provider's endpoint (again, don't add a trailing /v1 unless that provider's docs say to), swap the API key for the one the relay issued you, and use whatever model-name alias the relay documents if it maps Kimi K3 to something else
• Method 2 (OpenCode): if your relay isn't recognized as a built-in OpenCode provider, use OpenCode's generic custom OpenAI-compatible provider configuration — enter the relay's base URL and key, and you can still select Kimi K3
• Method 3 (CC Switch): CC Switch ships with 50+ built-in presets for popular relay providers — just pick the relay preset when adding a provider and paste in the corresponding key, which is simpler than filling in the address by hand

When picking a relay, confirm it actually proxies Kimi K3 specifically (not just an older Kimi model), and compare its billing against direct official pricing — see our AI API relay provider comparison for a broader rundown.

8. Troubleshooting checklist

9. Wrap-up: which one should I actually use