Kilo Code setup

The values

Start with the free test key: it answers every request with one fixed line and no tool calls, which proves the URL and the key are right without spending anything. Then paste your own key from the console. Credits from $5, no subscription.

Connect

1. Open Settings (the gear icon) and go to the Providers tab.
2. Scroll to the bottom and click Custom provider.
3. Set Provider ID to nokeep and Display name to nokeep.
4. Set Provider API to OpenAI Compatible.
5. Paste https://nokeep.ai/v1 into Base URL and sk-nokeep-test into API key.
6. Under Models, pick deepseek-v4.1-flash-uncensored and glm-5.3-flash-uncensored from the fetched list. Click Fetch models if the list is empty.
7. Click Submit, choose the model in the model picker and send a message. A reply that starts “Connected to” means it works.
8. Click Edit provider and swap in your own key from the console.

Set the limits below. Kilo doesn’t know these model ids, so without them it treats the context as 0, never compacts the conversation, and caps replies at 32,000 tokens.

Limits, tools and prices

The settings dialog covers the URL, key and models. Token limits, tool calls, prices and thinking go in kilo.jsonc: ~/.config/kilo/kilo.jsonc for every project, or ./kilo.jsonc in one. This is the whole provider; the key is read from NOKEEP_API_KEY if you set it there instead of in the dialog.

{
  "$schema": "https://app.kilo.ai/config.json",
  "model": "nokeep/deepseek-v4.1-flash-uncensored",
  "provider": {
    "nokeep": {
      "npm": "@ai-sdk/openai-compatible",
      "env": [
        "NOKEEP_API_KEY"
      ],
      "options": {
        "baseURL": "https://nokeep.ai/v1"
      },
      "models": {
        "deepseek-v4.1-flash-uncensored": {
          "name": "DeepSeek V4.1 Flash Uncensored",
          "tool_call": true,
          "attachment": true,
          "modalities": {
            "input": [
              "text",
              "image"
            ],
            "output": [
              "text"
            ]
          },
          "limit": {
            "context": 1000000,
            "output": 32768
          },
          "cost": {
            "input": 0.45,
            "output": 1.75,
            "cache_read": 0.011
          },
          "variants": {
            "think": {
              "reasoningEffort": "high"
            }
          }
        },
        "glm-5.3-flash-uncensored": {
          "name": "GLM 5.3 Flash Uncensored",
          "tool_call": true,
          "limit": {
            "context": 128000,
            "output": 32768
          },
          "cost": {
            "input": 0.2,
            "output": 0.65,
            "cache_read": 0.04
          }
        }
      }
    }
  }
}

• limit.context is when Kilo compacts the conversation; limit.output is sent as the cap on each reply.
• cost is per million tokens, cached reads included, so Kilo’s cost display matches the bill.
• attachment and modalities let you paste screenshots to DeepSeek. GLM reads text only.

Which model

Use DeepSeek for agent work. A whole repository fits in its context, it calls tools in every form, and the history an agent resends on each call bills at the cached $0.011 per million. Use GLM for short one-off tasks that don’t resend a long history, where its lower fresh-input and output prices win.

Both models have their refusals removed from the weights, so work near a sensitive subject, such as security testing on your own systems or moderation tooling, gets code instead of a refusal. Compare the models.

Thinking

DeepSeek answers at once unless a request names a reasoning_effort, which suits the quick edit-and-run loop of an agent. For planning or a hard bug, ask it to think: it takes none, low, high, max. Other apps’ minimal, medium and xhigh run at the nearest of these; any other value is refused with 400 invalid_reasoning_effort. Thinking is billed as output.

The think variant above sends reasoning_effort: high. Switch to it for a hard task and back for the rest; leave it out and DeepSeek answers at once.

What a session costs

An agent sends the whole conversation on every call: the instructions, the files it read, every step so far. Say a call sends 60,000 tokens, 55,000 of them the same start as the last call, and writes 1,000. On DeepSeek that call costs about $0.0046, so 200 calls are about $0.92. With no cache the same call would be $0.0288.

• Caching is automatic: nothing to turn on. A start of about 1,000 tokens or more, repeated within a few minutes, bills at the cached price.
• Each call holds what it could cost, its prompt and its max output, and settles to what it used. At 32,768 max output tokens the output part of the hold is about $0.0573.
• The console shows each call’s real tokens, cached tokens and credits. An agent’s own cost counter may not know the cached price, and then reads high.

How billing works.

If it doesn’t work

Every error is listed with its fix in Errors.