Kincode

kincode

A lightweight AI coding assistant for your terminal. Written in Go. Single binary. Zero dependencies.

Like Claude Code, but open-source and 10x lighter.

Features

• Single binary (~10MB), zero runtime dependencies
• Multi-provider: Anthropic, OpenAI, Ollama (any OpenAI-compatible endpoint)
• 12 built-in tools: bash, fileread / filewrite / fileedit / multiedit, glob, grep, webfetch, websearch, memory, agentspawn, todowrite
• Image input — vision blocks for Anthropic claude-3+ and OpenAI gpt-4o. Send screenshots, mockups, diagrams via POST /api/chat {message, images:[{media_type, data}]}
• Plan mode — POST /api/plan_mode {enabled} toggles a read-only gate. Agent investigates + drafts a markdown plan, doesn't modify until you approve
• Named subagents — drop a .md file at ~/.kincode/agents/.md or ~/.localkin/agents/.md (family-shared) with YAML frontmatter; the parent model dispatches via agent_spawn(agent="code-reviewer", task="...")
• External skill forge — ~/.kincode/skills/ and ~/.localkin/skills/ SKILL.md files become regular tools at boot. Same format kinclaw uses, so the family shares one skill marketplace
• Project memory — auto-loads KINCODE.md (or CLAUDE.md for cross-tool portability) from any parent dir of cwd
• Permission system with tool call confirmation (or -yolo to skip)
• Soul files with brain: config — switch persona AND provider/model per soul, kinclaw-kernel-compatible format
• -serve mode — HTTP+SSE server for desktop shell integration (paired with KinClaw Mac Code mode)
• Streaming responses with markdown rendering
• Context compaction: auto-summarizes when context gets large
• MCP support: connect any MCP-compatible tool server
• Persistent memory across sessions
• Web tools: fetch URLs and search the web (DuckDuckGo by default; set TAVILY_API_KEY to use Tavily for LLM-tuned results)
• Extended thinking: deep reasoning mode for complex problems
• Session persistence: auto-save/restore conversations across restarts
• Fast: Go concurrency, minimal memory footprint

Quick Start

# Install
go install github.com/LocalKinAI/kincode/cmd/kincode@latest

# Or download binary
curl -fsSL https://github.com/LocalKinAI/kincode/releases/latest/download/kincode-$(uname -s)-$(uname -m) -o kincode
chmod +x kincode

# Run with Anthropic
export ANTHROPIC_API_KEY=sk-ant-...
kincode

# Run with Ollama (free, local)
kincode -provider ollama -model qwen3:8b

# Run with OpenAI
OPENAI_API_KEY=sk-... kincode -provider openai -model gpt-4o

# Run with a soul file
kincode -soul coder.soul.md

# One-shot mode (non-interactive)
kincode "explain this codebase"

# YOLO mode (auto-approve all tool calls)
kincode -yolo "fix the failing tests"

Claude Login (No API Key Needed)

Use your Claude account directly — works with Free, Pro, and Max:

# First time: login via browser
kincode -login

# Then just use it (defaults to Haiku 4.5)
kincode

# Or specify a different model
kincode -model claude-sonnet-4-6

Your session auto-refreshes. No API key needed.

Soul Files

Define custom personas with .soul.md files. Soul format is compatible with the kinclaw kernel — same file drives either:

---
name: "kincode"
brain:
  provider: "ollama"          # anthropic | openai | ollama
  model: "kimi-k2.6:cloud"    # picks the brain when no -provider/-model on CLI
  temperature: 0.3
  context_length: 131072
rules:
  - "Read before you write"
  - "Stdlib first, deps last resort"
  - "Don't apologize. Don't hedge."
---

You are kincode, a senior coding agent. Ship clean, correct, minimal code...

CLI flag (-provider / -model) > soul brain: > legacy top-level model: > hardcoded default. Pass -soul to load:

kincode -soul ~/Documents/Workspace/kincode/souls/coder.soul.md

Server Mode

Run kincode as a daemon for desktop shell integration:

kincode -serve -port 5002 -soul souls/coder.soul.md

Exposes:

| Route | Method | Purpose | |---|---|---| | /api/health | GET | readiness probe | | /api/state | GET | {repo, model, provider, message_count} | | /api/repo | POST | chdir agent into a repo: {"path": "..."} | | /api/chat | POST | kick a turn: {"message": "..."} (returns 202; output via SSE) | | /api/chat | DELETE | interrupt the in-flight turn | | /api/events | GET | SSE stream of {type, ...} events |

Event types: user_message, text_delta, tool_call, tool_result, turn_done, error, usage.

KinClaw Mac's Code mode drives kincode through this surface. Server mode forces -yolo (no permission loop over HTTP) and falls back to ollama / kimi-k2.6:cloud if no Anthropic creds are configured — same Ollama install kinclaw uses, no extra setup.

Extended Thinking

Enable deep reasoning for complex problems:

---
name: "Architect"
thinking: true
thinking_budget: 15000
---

When enabled, the model will show its reasoning process in dim text before the final response. Useful for complex debugging, architecture decisions, and multi-step analysis.

Slash Commands

| Command | Description | |---|---| | /help | Show all commands | | /clear | Clear conversation history | | /compact | Manually compress context | | /model | Switch model mid-session | | /provider | Switch provider | | /soul | Load a soul file | | /memory | Show persistent memory | | /save | Save conversation to file | | /load | Load conversation from file | | /tokens | Show estimated token usage | | /diff | Show last file edit as colored diff | | /mcp | List connected MCP servers and tools | | /skill | List available skill templates | | /skill | Load a skill template for next message | | /skill create | Create a new skill interactively | | /version | Show version | | /quit | Exit |

Architecture

kincode (9MB single binary)
├── cmd/kincode/       # CLI entry point, flag parsing, soul loading
├── pkg/
│   ├── agent/          # Core loop: message → LLM → tool calls → loop
│   │                   # Context compaction (auto-summarize at 80%)
│   ├── provider/       # LLM providers (raw HTTP, no SDKs)
│   │   ├── anthropic   # Anthropic Messages API + SSE streaming
│   │   └── openai      # OpenAI-compatible (OpenAI/Ollama/DeepSeek/Gemini/...)
│   ├── tools/          # 10 built-in tools
│   │   ├── bash        # Shell execution (30s timeout, blocklist)
│   │   ├── file_*      # Read, write, edit (with diff visualization)
│   │   ├── glob/grep   # File and content search
│   │   ├── web_*       # Fetch URLs, DuckDuckGo search
│   │   ├── memory      # Persistent key-value store
│   │   └── agent_spawn # Sub-agent for parallel tasks
│   ├── repl/           # Interactive terminal
│   │                   # Readline, markdown rendering, 14 slash commands
│   └── permission/     # Tool call approval (yolo / confirm)
└── internal/
    └── mcp/            # MCP protocol client (JSON-RPC 2.0 over stdio)

Comparison

| | Claude Code | claw-code (Rust) | nano-claude-code (Python) | kincode (Go) | |---|---|---|---|---| | Binary size | ~100MB | ~15MB | N/A (needs Python) | 9MB | | Memory usage | ~150MB | ~30MB | ~80MB | ~20MB | | Dependencies | Node.js + npm | Rust toolchain | Python 3.10+ | zero | | Install | npm install | cargo build | pip install | download & run | | Providers | Anthropic | Multi | 10+ | any OpenAI-compatible | | Built-in tools | 40+ | ~20 | 13 | 10 + MCP | | Sub-agents | ✅ | ❌ | ✅ | ✅ | | Memory | ✅ | ❌ | ✅ | ✅ | | Context compaction | ✅ | ✅ | ✅ | ✅ | | MCP protocol | ✅ | ✅ | ❌ | ✅ | | Markdown rendering | ✅ | ✅ | ❌ | ✅ | | Diff visualization | ❌ | ❌ | ✅ | ✅ | | Web search | ❌ | ❌ | ✅ | ✅ | | Session persistence | ✅ | ✅ | ✅ | ✅ | | Soul files | ❌ | ❌ | ❌ | ✅ unique | | Open source | ❌ | ✅ | ✅ | ✅ |

MCP Support

Connect to any MCP-compatible tool server:

# Create mcp.json
cat > mcp.json  /mcp

MCP tools are automatically registered with a mcp_ prefix (e.g., mcp_read_file, mcp_search_repositories). The LLM can call them like any built-in tool.

Build from Source

git clone https://github.com/LocalKinAI/kincode.git
cd kincode
go build -o kincode ./cmd/kincode/

License

MIT

---

Built by the team behind LocalKin -- a self-evolving AI agent swarm with 78 specialized agents.

Source & license

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

• Author: LocalKinAI
• Source: LocalKinAI/kincode
• License: MIT

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