Every pattern is a real, runnable implementation — not a diagram or a blog post.

Install

pip install corecoder

Pick your model — any OpenAI-compatible API works. You can export env vars or drop a .env file in your project root:

# Kimi K2.5
export OPENAI_API_KEY=your-key OPENAI_BASE_URL=https://api.moonshot.ai/v1
corecoder -m kimi-k2.5

# Claude Opus 4.6 (via OpenRouter)
export OPENAI_API_KEY=your-key OPENAI_BASE_URL=https://openrouter.ai/api/v1
corecoder -m anthropic/claude-opus-4-6

# OpenAI GPT-5
export OPENAI_API_KEY=sk-...
corecoder -m gpt-5

# DeepSeek V3
export OPENAI_API_KEY=sk-... OPENAI_BASE_URL=https://api.deepseek.com
corecoder -m deepseek-chat

# Qwen 3.5
export OPENAI_API_KEY=sk-... OPENAI_BASE_URL=https://dashscope.aliyuncs.com/compatible-mode/v1
corecoder -m qwen-max

# Ollama (local)
export OPENAI_API_KEY=ollama OPENAI_BASE_URL=http://localhost:11434/v1
corecoder -m qwen3:32b

# One-shot mode
corecoder -p "add error handling to parse_config()"

Non-OpenAI providers (Bedrock, Vertex, Cohere, …)

For providers without an OpenAI-compatible endpoint, install the optional LiteLLM extra:

pip install 'corecoder[litellm]'

export CORECODER_PROVIDER=litellm
export CORECODER_MODEL=anthropic/claude-3-haiku   # any LiteLLM model string
export ANTHROPIC_API_KEY=sk-ant-...
corecoder

LiteLLM routes through to 100+ providers (Bedrock, Vertex AI, Cohere, Groq, Replicate, Anyscale, etc.) using one model-string convention. The default openai backend is unchanged.

Architecture

The whole thing fits in your head:

corecoder/
├── cli.py            REPL + commands               218 lines
├── agent.py          Agent loop + parallel tools    122 lines
├── llm.py            Streaming client + retry       156 lines
├── context.py        3-layer compression            196 lines
├── session.py        Save/resume                     68 lines
├── prompt.py         System prompt                   33 lines
├── config.py         Env config                      55 lines
└── tools/
    ├── bash.py       Shell + safety + cd tracking   115 lines
    ├── edit.py       Search-replace + diff            85 lines
    ├── read.py       File reading                     53 lines
    ├── write.py      File writing                     36 lines
    ├── glob_tool.py  File search                      47 lines
    ├── grep.py       Content search                   78 lines
    └── agent.py      Sub-agent spawning               58 lines

Use as a Library

from corecoder import Agent, LLM

llm = LLM(model="kimi-k2.5", api_key="your-key", base_url="https://api.moonshot.ai/v1")
agent = Agent(llm=llm)
response = agent.chat("find all TODO comments in this project and list them")

Add Your Own Tools (~20 lines)

from corecoder.tools.base import Tool

class HttpTool(Tool):
    name = "http"
    description = "Fetch a URL."
    parameters = {"type": "object", "properties": {"url": {"type": "string"}}, "required": ["url"]}

    def execute(self, url: str) -> str:
        import urllib.request
        return urllib.request.urlopen(url).read().decode()[:5000]

Commands

/model           Show current model
/model <name>    Switch model mid-conversation
/compact         Compress context (like Claude Code's /compact)
/tokens          Token usage + cost estimate
/diff            Show files modified this session
/save            Save session to disk
/sessions        List saved sessions
/reset           Clear history
quit             Exit

Saved session IDs are sanitized before they become filenames, so resume data stays inside ~/.corecoder/sessions.

How It Compares

| | Claude Code | Claw-Code | Aider | CoreCoder | |---|---|---|---|---| | Code | 512K lines (closed) | 100K+ lines | 50K+ lines | ~1,400 lines | | Models | Anthropic only | Multi | Multi | Any OpenAI-compatible | | Readable? | No | Hard | Medium | One afternoon | | Purpose | Use it | Use it | Use it | Understand it, build yours |

The Deep Dive

I wrote 7 articles breaking down Claude Code's architecture — the agent loop, tool system, context compression, streaming executor, multi-agent, and 44 hidden feature flags. If you want to understand why CoreCoder is designed this way, start there.

FAQ

Does CoreCoder support Skills / Subagents / MCP?

No, and that's intentional. CoreCoder is the minimal runnable core — agent loop, tools, streaming, compaction. Skills, Subagents, MCP, hooks, and plugins are upper-layer features that Claude Code layers on top; if CoreCoder had them too it would stop being a teaching artifact. The architecture articles above cover how those systems work in Claude Code, so you can add them yourself if you need to.

If you want Skills specifically, the recipe is small: scan ~/.claude/skills/*.md at startup, list their titles in the system prompt, and let the agent ask for a skill by name before you inline that file's body into the conversation.

Related Projects

• CodeJoust — a CLI arena that races Claude Code, aider, Codex, and Gemini (Cursor + OpenHands next) on the same bug in isolated git worktrees, scores by tests+cost+diff+time, hands you the winning patch. If you ever wondered which AI coding CLI is actually better for your task, CodeJoust answers it empirically.
• AnyCoder — a practical terminal AI coding agent built on the same architecture as CoreCoder but with litellm, session persistence, and 100+ model support. Use this one if you want a tool; use CoreCoder if you want to read source.
• LiteBench — one-command LLM / agent benchmark. Ships 7 built-in tasks (HumanEval/GSM8K/MMLU/...) and YAML-defined custom tasks, with a single-file HTML dashboard.
• RepoWiki — open-source DeepWiki alternative. pip install repowiki, one command to turn any local or GitHub repo into a wiki with dependency graph, architecture diagram, and LLM-generated module pages.

License

MIT. Fork it, learn from it, ship something better. A mention of this project is appreciated.

Built by Yufeng He · Agentic AI Researcher @ Moonshot AI (Kimi)

Claude Code Source Analysis — 170K+ reads, 6000 bookmarks on Zhihu