Kimicode Vision Bridge

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

| Result | Action | |--------|--------| | Found | Pass | | Not found | Fail. "KimiCode CLI not found. Install from https://www.kimi-cli.com" |

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):

| Windows | macOS | Linux | |---------|-------|-------| | %APPDATA%\kimi\config.json | ~/Library/Application Support/kimi/config.json | ~/.config/kimi/config.json | | %USERPROFILE%\.kimi\config.json | ~/.kimi/config.json | ~/.kimi/config.json |

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

| Result | Action | |--------|--------| | API key + vision model set | Pass | | API key missing | Fail. "No API key configured. Run kimi config set or edit the config file." | | Model missing or text-only | Fail. "No vision model configured. Set a multimodal model via kimi config set model (e.g., moonshot-v1-vision, gpt-4o, claude-3.5-sonnet)." |

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:

| Scenario | Prompt | |----------|--------| | Generic | "Describe every visible element — text, layout, colors, positions, any errors or warnings." | | UI/dialog | "Read every label, button text, input field value, and error message in this screenshot." | | Code | "Read all visible code including line numbers, syntax highlighting, and any squiggly/error indicators." | | Chart/graph | "Describe the chart type, axes labels, data ranges, trend direction, and any annotations." | | Document | "Transcribe the visible text exactly. Note any formatting (bold, headers, tables)." |

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

| Flags | Output format | How to parse | |-------|--------------|--------------| | --quiet | Plain text, final message only | Read directly | | --output-format=stream-json | JSONL, one JSON per line | grep '"role":"assistant"' \| tail -1 \| jq -r '.content' |

Inject into Agent context:

[Vision bridge: KimiCode print mode]

[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

| Mistake | Fix | |---------|-----| | Using a text-only model | Run kimi config set model to switch | | Image path contains spaces or special chars | Wrap path in quotes or use a temp file with a simple name | | Expecting KimiCode to take screenshots | Use OS tools; KimiCode is the analysis pipe, not the capture tool | | Forgetting to verify prerequisites first | Always run Check 1 and Check 2 before attempting the bridge | | Not checking exit codes | 0=success, 1=permanent error (auth/config), 75=transient (rate limit, retry) |

Error Recovery

| Symptom | Likely cause | Action | |---------|-------------|--------| | kimi: command not found | CLI not on PATH | Install from https://www.kimi-cli.com | | Exit code 75 | Rate limit / transient | Wait 10s, retry | | Exit code 1 | Auth or config error | Run kimi config to check API key and model | | Empty or nonsensical output | Model may not be vision-capable | Verify the model supports multimodal input | | "Image input not supported" in output | Model is text-only | Switch to a vision model in KimiCode config | | Base64 too large for stdin | Image too big | Use file-reference approach (Approach 1) | | Output appears truncated | Long response | Use --output-format=stream-json for reliable capture |

Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: Dqz00116
• Source: Dqz00116/skill-lib
• License: MIT

Install and usage instructions live in the source repository linked above.