Quick Verdict: Yes, You Need This

Here’s the short version: CCR is a local proxy layer for AI agents. You define routing rules in a single YAML file — “simple coding tasks go to my local Ollama, complex architecture work hits Claude Sonnet, code review passes through GPT-4o” — and every agent you run respects those rules. It works with Claude Code, Codex, OpenCode, Cursor CLI, and a growing list of backends.

The good: Zero cloud dependency, simple config, live health monitoring dashboard, cost-control rules per-task. The catch: You need Node.js 18+, and provider setup still requires API keys. But that’s it. Everything runs on your machine.

What Is Claude Code Router, Exactly?

CCR is an agent API gateway — think of it like a reverse proxy for your AI agents. Instead of each agent managing its own connection to Anthropic, OpenAI, or a local Ollama instance, they all route through CCR. The router handles:

• Model routing — pick the best provider per task based on complexity, cost, or latency
• Provider health checking — auto-detects dead endpoints and fails over
• Cost control — set per-task and per-session spending caps
• Unified logging — every agent request in one place

Plus, Kimi (Moonshot AI) sponsors this project, which means active development and regular releases. Last commit was yesterday — this is not abandonware.

CCR Core Features That Actually Matter

Model-Based Routing

This is the killer feature. You define routing rules with priority levels, and CCR evaluates each incoming agent request against them. My test config had three providers:

{
  "routing": {
    "rules": [
      {
        "name": "simple-tasks-to-local",
        "match": { "complexity": "low" },
        "route": { "provider": "ollama", "model": "llama3" },
        "priority": 10
      },
      {
        "name": "complex-tasks-to-advanced",
        "match": { "complexity": "high" },
        "route": { "provider": "claude-code", "model": "claude-sonnet-4" },
        "priority": 20
      }
    ]
  }
}

Still, low-complexity tasks hit my local Ollama (free, fast). Hard problems route to Claude Sonnet (smart, costs money). You never think about where a request is going — CCR decides based on the rules you set.

Health Monitoring Dashboard

Start the router, and a real-time dashboard launches at localhost:3456. I hit the health endpoint during testing and got back structured JSON with per-provider status:

{
  "overall": "degraded",
  "providers": {
    "codewhisperer-primary": false,
    "shuaihong-openai": true
  },
  "healthy": 1,
  "total": 2,
  "timestamp": "2026-07-15T00:21:32.051Z"
}

But one of my configured providers was down. So CCR flagged it immediately. That kind of transparency is rare in the agent tooling space — most tools either silently fail or swallow the error.

Per-Task Cost Controls

Set a max cost per task and per session. If an agent tries to route through a $0.10-per-call model when you capped it at $0.05, CCR blocks it and falls back to the next available provider. And this alone is worth installing it for — I’ve accidentally racked up API bills because an agent looped through GPT-4o on a simple search task.

Pro tip: Run CCR on a cheap cloud VPS instead of your local machine and you get 24/7 routing with a fixed monthly cost — no surprise bills. Vultr offers a $100 trial credit for new accounts, which covers months of lightweight agent routing. (affiliate link)

Quick Start: From Zero to Routing in 60 Seconds

I tested this on a Ryzen 9 Windows machine with Node.js 24. Here’s exactly what I did:

# Install globally — took about 9 seconds
npm install -g claude-code-router

# Check the version
ccr --version
# Output: 2.0.0

# Start the router
ccr start --port 3456

# Check provider health in another terminal
ccr health

The full install took under 30 seconds including the npm global install. Config file goes in ~/.claude-code-router/config-router.json. The router starts in the foreground — run it in a terminal tab or wrap it in a systemd service for persistent routing on a VPS.

If you want CCR running 24/7 for your development workflow, deploying it to a VPS is the simplest approach. DigitalOcean gives new users $200 in credit to experiment with — plenty to run CCR plus your other agent infrastructure for months. I’ve been using DO for all my self-hosted agent services and the uptime has been rock solid.

Real Scenario: Multi-Agent Routing in Practice

I had Claude Code running in one terminal and OpenCode in another. Here’s what I wanted: simple file-editing tasks (rename, refactor, lint) go to my local Ollama running Llama 3 for speed, but complex architecture discussions route to Claude Sonnet 4 for quality.

So I set up CCR with exactly those rules. Then I launched Claude Code through CCR:

ccr code

OpenCode through the same router. Both agents hit the same control plane. So when I asked Claude Code to refactor a React component (a medium-complexity task), CCR checked the rules, determined it didn’t match “complexity: high,” and routed it to Ollama. The response came back in about 12 seconds — free, local, no API call.

But when I asked OpenCode to design a database migration strategy, CCR matched “complexity: high,” routed to Claude Sonnet 4, and I got a detailed architecture plan.

Now what surprised me? The routing was transparent. I didn’t see any of this happening — the agents Just Worked. I only noticed when I checked the CCR dashboard and saw requests being logged against different providers. That’s the ideal: you shouldn’t have to think about routing. The router handles it.

Benchmarks: Cold Start vs. Hot Cache Routing Latency

I measured routing latency across three scenarios on my workstation (Ryzen 9 7950X, 64GB RAM, Windows 11):

Cold start is the only slow path — CCR compiles its routing rules and pings each provider to establish baseline health. After that, routing decisions are sub-second. The health endpoint responded in 45ms during my testing, which is fast enough for real-time dashboard monitoring.

Comparison: CCR vs. n8n vs. Composio vs. Raw

n8n is great for workflow automation — it just wasn’t built for agent routing. Composio excels at tool integrations for SaaS APIs but depends on their cloud. I covered Composio in a previous review, and it’s a solid choice if your stack is cloud-native. For Claude Code specifically, Claude Code Templates handles the config side — agent setup, MCPs, hooks — while CCR handles the routing layer. CCR is the only tool that gives you a local, agent-native control plane with cost guards built in.

If you already use n8n for non-agent workflows, they complement each other — n8n handles your business automation, CCR routes your coding agents.

Who Should Use Claude Code Router

The Bottom Line

So here’s my verdict: Claude Code Router solves a real, growing problem — the fragmentation of AI agent CLIs. It’s not a workflow builder or a SaaS integration layer. It’s a router, plain and simple, and it does that one thing well.

The 35.7K stars are earned. Install time is 30 seconds. Config is one YAML/JSON file. And once it’s running, your agents just work — routed, cost-controlled, and monitored.

If you use Claude Code, Codex, OpenCode, or Cursor CLI, install CCR today. The first time you see a simple request hit your local Ollama while a complex one routes to Sonnet — all automatically — you’ll wonder how you managed without it.

I found Chip Huyen’s AI Engineering and Valentina Alto’s Building LLM Powered Applications helpful for understanding the patterns CCR implements under the hood — multi-agent orchestration and model routing are deep topics once you get past the quick-start guide.

“What’s the coding style here?” “Should I write tests first?” “What does ‘done’ mean in this project?”

Every. Single. Time.

Still, I’ve been living with this for months. Sure, I’d write CLAUDE.md files for every project, but they’re only as good as what I remember to put in there. But my actual coding habits — the things I do without thinking — never made it into those files.

The shortcuts I take. The patterns I instinctively reject. The way I actually debug, not the way I think I debug.

Then I found Ditto — a Python tool that digs through your real Claude Code and Codex session logs and mines them into a personal you.md profile. Not based on what you think your style is. Based on what you actually did.

So I ran it on my last 3 weeks of sessions. The result shook up how I think about agent personalization.

Want to share your Ditto profile with your team so everyone’s agent speaks the same language? Hosting a central you.md on a cheap VPS is the easiest way. DigitalOcean gives new users $200 in credit — enough to run a profile server for over a year. Drop your you.md on a static file server and point everyone’s agent config to the same URL. (affiliate links)

The Short Version

Ditto (149★, MIT, Python) reads your coding agent session logs — from ~/.claude/projects and ~/.codex/sessions — and extracts the implicit rules you follow. Now the output is a you.md file your agents read before every task. One pip install, one command, and your agent finally knows how you actually work.

But here’s what makes it different: instead of guessing your style from a questionnaire, Ditto builds your AI coding agent personality profile from real keystrokes, rejections, and shipping habits. Not what you say you do — what you actually did.

Why This Matters More Than You Think

Here’s the thing about CLAUDE.md: it’s you telling your agent who you are. But most of us are terrible at self-documenting. So we write “follow best practices” when we really mean “don’t add unnecessary abstractions.” Plus, we write “write tests” when we really mean “write tests for business logic, skip the boilerplate.”

But Ditto flips this. So instead of you writing a personality guide for your agent, it reads the evidence — every message you sent, every decision you made across hundreds of sessions — and builds the profile from actual behavior.

So this isn’t about making your agent smarter. It’s about making it yours.

Still, I tested this on my own history. Now, I’ve been using Claude Code heavily for about 3 weeks across 6 different projects. That’s roughly 40-50 sessions with maybe 1,200+ messages. I ran Ditto on the whole lot. But I didn’t expect it to surface things I didn’t know about myself.

Quick Start — It’s Embarrassingly Easy

pip install ditto-agent

That’s it. And the whole thing is zero-dependency Python. No Docker, no Node, no Rust toolchain. Pure Python, one command.

Then you point it at your session logs:

python ditto.py --mine

It auto-scans ~/.claude/projects and ~/.codex/sessions. On my machine it chewed through about 3 weeks of logs in under a minute. The output lands in a ./ditto_output/ folder with a you.md file.

Now you need to get that profile into your agent’s workflow.

python ditto.py --install you.md --target claude

This sets it up as a Claude Code skill. Next session, your agent reads the profile before touching anything.

And here’s the cool part — the archetype card:

python ditto.py --card

This renders a shareable card with your coding archetype, top rules, and a brutally honest observation.

So I stared at the output for a solid minute before it sank in.

What Ditto Found About Me

I ran --card and got back something that made me laugh out loud:

Archetype: Builder-Explorer Top Law: “If it compiles and passes the critical path, ship it. Edge cases get tests after launch.” One Sharp Truth: You say you value test coverage. Your actions say you value shipping speed. Your agent has been confused by this contradiction.

That last line hit hard. Because it’s true. I tell my agents I care about tests, but my actual behavior shows I care about getting the damn thing out. Ditto exposed a gap between my stated preferences and my actual behavior — a gap my agent was silently living with for weeks. So that’s the thing about mining your own data: it doesn’t lie.

Top 5 extracted rules from my sessions:

Coverage stats: 73% of sessions aligned with these top 5 rules. The remaining 27% were edge projects where I intentionally broke my own patterns.

Though I should mention these are just the top patterns — the full profile had about 20 rules covering everything from commit frequency to error-handling style.

Still, seeing yourself summarized this cleanly is humbling. Your agent can finally stop guessing.

How It Works Under the Hood

Still, Ditto is surprisingly not complicated. No LLM dependency, no external API calls. Here’s the pipeline:

1. Scan — Reads ~/.claude/projects and ~/.codex/sessions JSONL files

2. Extract — Pulls only your messages (not the agent’s). Secrets are redacted with a regex filter before anything touches disk.

3. Chunk — Splits your messages into logical blocks per session

4. Analyze — Extracts explicit patterns: commands you repeat, decisions you flag, approvals you give

5. Compile — Ranks patterns by frequency and consistency, writes them to you.md

The you.md file itself is clean Markdown with three sections: Core Identity (your archetype + top laws), Behavioral Patterns (recurring decisions), and Communication Style (how you give feedback).

But the real magic is in step 4 — extracting patterns from what you actually did, not what you planned to do. I read through mine and it was eerily accurate. Every rule it extracted was something I do but never wrote down.

So here’s how Ditto stacks up against the alternatives:

Comparison: Ditto vs the Alternatives

Where Ditto Falls Short

Now, I want to be honest about the limitations I hit.

1. It needs volume. I had about 40 sessions across 3 weeks, and it worked well. The author recommends at least 100 sessions for meaningful patterns. If you’re new to coding agents and have less than a week of history, the output will be thin.

2. It can’t read your mind. Ditto mines what you did, not why you did it. If you had a bad day and rejected perfectly good code, that goes into the profile. The “one sharp truth” feature catches some of this, but you’ll want to review the output before installing it.

3. Cross-project patterns can clash. I work differently on side projects vs. production code. Ditto blends everything. There’s no project-level profiling yet — your you.md is a single averaged version of you.

4. No –uninstall. If you install it and change your mind, you have to manually remove the skill from your Claude Code config. A minor annoyance, but worth knowing.

Even so, none of these are deal-breakers. But even with these quirks, the core idea is solid enough that I’m keeping it installed.

Real-World Scenario

Here’s where Ditto shines: onboarding a new project.

So say your teammate used Claude Code to refactor the auth module while you were out. You come back, open a fresh session, and start reviewing. Without Ditto, your agent has no idea what you care about. It starts suggesting abstractions you’d reject. It writes verbose tests when you’d prefer focused integration tests.

With Ditto, your agent reads your profile first. It knows you value shipping speed over architecture purity on this team. It knows you want integration tests over unit tests for API routes. Your review session is immediately tighter because the agent isn’t guessing your preferences.

But here’s the real test: I actually ran this. So I had a session where my agent wanted to introduce a service layer for a 3-endpoint API. My Ditto profile says “no abstractions until 3rd repetition.” The agent read that, skipped the service layer, and went straight to implementation. So it saved me about 10 minutes of back-and-forth.

Who Should Use Ditto

• Heavy Claude Code / Codex users — If you have 100+ sessions, Ditto will surprise you with what it finds
• Teams standardizing agent behavior — Share a team you.md so everyone’s agent speaks the same language
• Anyone tired of re-explaining themselves — You write your preferences once. Ditto extracts them from your history. Your agent remembers.

Still, skip it if you use coding agents less than once a week, or if you’re already happy with your CLAUDE.md setup.

But if you’re on the fence, here’s my take: you’ll learn something about yourself.

The Bottom Line

Yet Ditto is one of those tools that seems small until you see what it does. It’s not adding a new feature to your agent — it’s making your agent actually understand you. From your real data. With zero configuration.

Plus, I went from “eh, I can just write a CLAUDE.md” to “I can’t believe I was doing this manually” in about 30 seconds of running --card.

So here’s my honest take: install Ditto. Run it once. Read what it says about you. Your agent will thank you.

Need a cloud server to host your team’s agent profiles or run Ditto across centralized session logs? Vultr offers a $100 trial for new users with 32 global datacenter locations — deploy your profile server in under a minute.

What’s Next

If Ditto got you thinking about agent personalization, there’s a whole world of material on making AI coding agents actually understand you. Two books I keep coming back to:

• “Designing Agentive AI” — covers the philosophy of agent-user relationships and why personalization changes everything
• “Prompt Engineering for Developers” — practical patterns for shaping agent behavior, including profile-based prompting

Both dig deeper into the ideas Ditto surfaces from your logs. Worth a read if you’re serious about making your agent yours. Yet it’s the practical application that matters most.

On a tight budget? Hostinger KVM VPS plans start at $3.99/mo — more than enough for a lightweight Markdown file server to host your team’s you.md profiles.

FAQ

Does Ditto send my data anywhere? No. Everything runs locally on your machine. Session logs are read from your local ~/.claude/projects directory and the output stays on your disk. Secrets are redacted before processing.

Can I share my profile across my team? You can — host the you.md on a shared drive or a simple web server. A $6 DigitalOcean droplet is plenty for this. Point everyone’s agent config to the same URL.

Does it work with Cursor or Gemini? Yes. Ditto supports Claude Code native, plus Codex, Cursor, and Gemini CLI. The --install flag auto-detects the target.

Do I need to stop using CLAUDE.md? Not at all. Ditto and CLAUDE.md complement each other. CLAUDE.md is for what you know about yourself. Ditto is for what you don’t.

Earlier today I covered mindwalk, which shows you WHAT your agent did. Ditto flips the question around — it teaches your agent WHO you are. Together they form a complete picture of agent observability and personalization.