KimiCode Vision Bridge

Overview

Routes images through KimiCode CLI's print mode (kimi --print) to give a non-vision Agent LLM visual understanding. Kimi is a multimodal model; print mode provides a non-interactive, programmatic pipe — the Agent submits an image + question via CLI, Kimi returns a text description on stdout.

Agent (no vision)                KimiCode CLI                  Kimi multimodal model
     │                                │                              │
     │  image + question              │                              │
     ├───────────────────────────────→│                              │
     │  kimi --print -p "..."         │                              │
     │                                ├─────────────────────────────→│
     │                                │     API call with image      │
     │                                │←─────────────────────────────┤
     │                                │     text response            │
     │←───────────────────────────────┤                              │
     │  text on stdout                │                              │
     ▼                                ▼                              ▼

Print mode docs: https://www.kimi-cli.com/en/customization/print-mode.html

When to Use

Use this skill when:

• The current Agent LLM cannot process images directly (no vision capability)
• An image needs to be read or analyzed — screenshots, photos, diagrams, charts, document scans, UI mockups
• KimiCode CLI is installed and configured with a vision-capable model on the system

Do NOT use when:

• The Agent already has native image input — this skill adds an unnecessary hop
• The task is pure text analysis with no visual component
• KimiCode is not installed or lacks a vision model

Prerequisites (MUST verify before proceeding)

Both checks must pass. If either fails, stop and report the failure.

Check 1: KimiCode CLI (kimi) is installed

Windows (PowerShell):

Get-Command kimi -ErrorAction SilentlyContinue | Select-Object -ExpandProperty Source

macOS / Linux:

which kimi || command -v kimi

Check 2: A multimodal (vision-capable) model is configured

Locate the config file and verify an API key and a vision model are set.

Config locations (try in order):

Verify:

1. A non-empty API key (fields: apiKey, token, api_key, or under providers)
2. A model name (fields: model, defaultModel) — must be vision-capable
3. If config uses env vars (e.g., $KIMI_API_KEY), verify those are set

The Pipe: Core Workflow

Once prerequisites pass, the bridge has two steps.

Step A: Submit image + question to Kimi via print mode

The Agent already has an image (from the user, from a file, from a prior tool call). Combine it with a clear instruction and pipe it through kimi --print.

Approach 1 — File reference (recommended)

Point Kimi at the image file on disk. KimiCode's file-read tool loads and analyzes it.

kimi --quiet -p "Describe every visible element in this image in detail: /path/to/image.png"

Approach 2 — Inline base64 via JSONL stdin (fully programmatic)

Pipe the image as base64 directly — no temp file needed.

BASE64=$(base64 -w 0 /path/to/image.png)
echo "{\"role\":\"user\",\"content\":[{\"type\":\"image_url\",\"image_url\":{\"url\":\"data:image/png;base64,$BASE64\"}},{\"type\":\"text\",\"text\":\"Describe every visible element in this image in detail.\"}]}" \
  | kimi --print --input-format=stream-json --output-format=stream-json

Windows PowerShell equivalent:

$base64 = [Convert]::ToBase64String([IO.File]::ReadAllBytes("C:\path\to\image.png"))
$msg = '{"role":"user","content":[{"type":"image_url","image_url":{"url":"data:image/png;base64,' + $base64 + '"}},{"type":"text","text":"Describe every visible element in this image in detail."}]}'
$msg | kimi --print --input-format=stream-json --output-format=stream-json

Effective prompts for the image question:

Step B: Read the text result and feed into Agent context

Inject into Agent context:

[Vision bridge: KimiCode print mode]
<text from stdout>
[End vision bridge]

Complete pipeline example

IMAGE="/path/to/image.png"
RESULT=$(kimi --quiet -p "Describe every visible element in $IMAGE in detail" 2>/dev/null)
echo "[Vision bridge: KimiCode print mode]"
echo "$RESULT"
echo "[End vision bridge]"

Image Sources

The bridge works with any image the Agent can reference. Common sources:

• User-provided file path — kimi --quiet -p "Describe ~/Downloads/screenshot.png"
• Screenshot captured on-the-fly — capture with OS tool first, then feed the saved file (macOS: screencapture, Windows: PowerShell GDI+, Linux: ImageMagick/gnome-screenshot)
• Image from a prior tool call — pass the path from a previous download/generation step
• Clipboard image — save to temp file first, then bridge

Screenshot capture is not part of the bridge skill itself — use platform-native tools.

Iterative Refinement

1. Narrow the question: "Focus only on reading every text string in the dialog box."
2. Compare states: Submit two images and ask "Compare these two screenshots and describe what changed."
3. Crop and retry: Crop to a sub-region with OS tools and re-submit

Common Mistakes

Error Recovery