Use local Ollama models with Kimchi

In this tutorial, you'll pull a lightweight local model with Ollama, start Kimchi, and verify that the model is automatically discovered and available for coding tasks. You'll then use it directly from the model picker and as a delegated role in multi-model mode.

This tutorial is intended for those who want to run inference locally. Whether to work offline, reduce API costs where possible, or experiment with open-weight models. It assumes you have:

Kimchi Coding installed and authenticated; see Getting started if not
Basic familiarity with the terminal

By the end of this tutorial, you'll be able to:

Pull and serve a local model with Ollama
Confirm Kimchi discovers it automatically on startup
Select it manually from the model picker
Understand how it fits into Kimchi's multi-model role system

Background

Kimchi probes a locally-running Ollama server on every startup. If Ollama is running and has models installed, they are automatically registered under an ollama provider and appear in the /model picker as ollama/<model-name>. No edits to configuration files are needed. See Local Ollama Models in the CLI reference for full details on the probe, host configuration, and capability detection.

Before you start

Install Ollama from ollama.com if you haven't already. Verify the installation:

ollama --version

Pull and serve a local model

Pull a model

Pull a small model to keep the download fast. llama3.2:1b is a good starting point — it's under 1 GB and capable enough for straightforward coding tasks:

ollama pull llama3.2:1b

If you want a larger model with more capability, llama3.1:8b is a solid general-purpose choice at around 5 GB.

Start Ollama

Ollama runs as a background daemon on macOS and Linux after installation. Verify it is reachable:

curl http://localhost:11434/api/tags

You should see a JSON response listing your installed models. If the command fails, start Ollama manually:

ollama serve

Leave that terminal open and continue in a new one.

Start Kimchi

Launch Kimchi normally:

kimchi

Kimchi probes Ollama during startup.

Verify discovery

Once Kimchi is running, confirm the model was discovered by checking models.json:

cat ~/.config/kimchi/harness/models.json | jq '.providers.ollama.models[] | {id, input, reasoning}'

You should see your model listed. For llama3.2:1b, it looks like this:

{
  "id": "llama3.2:1b",
  "input": ["text"],
  "reasoning": false
}

For a vision-capable model like llava:7b, the input array includes "image":

{
  "id": "llava:7b",
  "input": ["text", "image"],
  "reasoning": false
}

These fields reflect what the Ollama probe detected from the model's capabilities.

📘
Cost fields are always zero for Ollama models. Local inference is not metered or billed, and Kimchi reports it as such in models.json accordingly.

Use your Ollama model

Select it manually from the model picker

To switch to your Ollama model for the current session, run /model from the Kimchi prompt and pick it from the list:

/model

Your model appears as ollama/llama3.2:1b (or whichever model you pulled). Selecting it routes all messages in the session to that model.

This is the most direct way to use a local model.

Multi-model role assignment

When Kimchi runs in multi-model mode, it automatically includes discovered Ollama models in the explorer, reviewer, and builder role pools. This happens at startup without any configuration — keeping Ollama running is all that's required.

Ollama models are never assigned to the orchestrator, planner, or judge roles.

What to expect

Once Kimchi discovers your Ollama model:

It appears in /model picker as ollama/<model-name>
It is registered in ~/.config/kimchi/harness/models.json under the ollama provider
It is available in the explorer, reviewer, and builder pools for multi-model tasks
When Ollama goes offline, the model is automatically removed from models.json on the next startup

Next steps

CLI reference — Local Ollama Models

Full details on the Ollama probe, host configuration, and how capabilities are detected.

Multi-model orchestration

How Kimchi assigns tasks across models and roles.