Kimi K3 in OpenCode: What One Finished Coding Task Actually Cost

Update — July 23, 2026: I published a fuller reproducible guide covering the Starter, OpenCode configuration, evidence JSON, measured run, and its limitations:
Kimi K3 in OpenCode: A Reproducible Starter and One Measured Agent Run

Kimi K3 launched with impressive benchmark results—and a lot of debate about its price.

For developers using coding agents, however, price per million tokens is only part of the story.

A more useful question is:

How much does it cost to finish an actual coding task—with file reads, edits, tool calls, and passing tests?

We ran one controlled Kimi K3 coding task through OpenCode and recorded the result.

Disclosure: I work on Vancine, a third-party API aggregation platform. Vancine is not Moonshot AI and is not an official Kimi service. The cost below is measured Vancine usage for one specific run, not official Kimi pricing or a fixed-price promise.

The task

The agent received a small repository containing a faulty leap-year implementation.

It had to:

• inspect the source code and failing tests;
• identify the bug;
• edit the source file;
• leave the test file unchanged;
• run the actual test suite;
• finish with all tests passing.

The run used OpenCode v1.18.3 inside an isolated Docker Linux ARM64 environment.

The result

The 28,707 total tokens included:

• 3,746 input tokens;
• 1,019 output tokens;
• 902 reasoning tokens;
• 23,040 cached-read tokens.

The run completed without recorded HTTP 429 responses, HTTP 5xx responses, provider errors, or permission failures.

You can inspect the sanitized machine-readable evidence here:

Kimi K3 OpenCode verification evidence

What this result proves

For this specific task, Kimi K3 successfully:

• inspected multiple files;
• understood the failing behavior;
• made the required source change;
• invoked the test command;
• reached a passing solution.

The source file was modified, the test file remained unchanged, and no unexpected files were created.

What it does not prove

This is one controlled task—not a general benchmark.

It does not prove that:

• every Kimi K3 task will cost $0.19;
• every repository will complete in six steps;
• Kimi K3 is universally better than Claude, GPT, GLM, or other models;
• every OpenCode version or coding-agent client behaves identically;
• $1 of starting credit will complete a particular agent task.

Cline and Roo Code configuration examples are included in the starter repository, but they have not yet been independently live-verified. Only the recorded OpenCode v1.18.3 task is verified.

Why cost per finished task matters

Coding agents rarely make one isolated API request.

A normal agent loop may:

1. read multiple files;
2. build and rebuild context;
3. reason about the change;
4. call tools;
5. edit code;
6. run tests;
7. inspect failures;
8. retry until the task is complete.

Because of that, the cheapest model per token is not necessarily the cheapest model per finished task.

A useful coding-model evaluation should report:

• whether the task was completed;
• whether the tests passed;
• model steps;
• successful and failed tool calls;
• total tokens;
• elapsed time;
• final billed usage.

One task is not a leaderboard, but it is a more concrete starting point than benchmark scores or token prices alone.

Using Kimi K3 with OpenCode

Vancine exposes the model alias kimi-k3 through an OpenAI-compatible API.

A minimal OpenCode provider configuration looks like this:

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "vancine": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Vancine",
      "options": {
        "baseURL": "https://vancine.com/v1",
        "apiKey": "{env:VANCINE_API_KEY}"
      },
      "models": {
        "kimi-k3": {
          "name": "Kimi K3"
        }
      }
    }
  }
}

Keep the API key in an environment variable:

export VANCINE_API_KEY="your-api-key"
opencode

Then select:

vancine/kimi-k3

Do not commit real API keys to source control or paste them into shared configuration files.

Direct API request

The same model can be called through the OpenAI-compatible Chat Completions endpoint:

curl https://vancine.com/v1/chat/completions \
  -H "Authorization: Bearer $VANCINE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k3",
    "messages": [
      {
        "role": "user",
        "content": "Review this function and identify the bug."
      }
    ]
  }'

The Vancine model alias is kimi-k3. Kimi’s first-party documentation uses k3 for the official Kimi Code model ID, so always use the identifier required by the provider you are connecting to.

Reproduce the setup

The public starter repository includes:

• OpenCode configuration;
• Cline and Roo Code configuration examples;
• cURL, Python, and Node.js requests;
• offline configuration validation;
• sanitized OpenCode evidence;
• credential-safety guidance.

View the Kimi K3 API Starter on GitHub

You can also open the complete quick start here:

Kimi K3 API for coding agents

New Vancine accounts currently receive $1 in starting credit, with no credit card required.

Usage depends on the model, prompt size, context, tool loop, and number of requests. The starting credit does not guarantee that any particular coding task will complete within that amount.

The broader takeaway is simple:

For coding agents, measure the cost of reaching a tested solution—not just the price of generating a token.