Skip to main content
Kodelyth ECC
comparison

Kodelyth ECC vs Continue.dev — Config-Driven Assistant vs Catalog Toolkit

Continue.dev is a config-driven AI coding assistant for VS Code + JetBrains with first-class local model support. Kodelyth ECC is a catalog toolkit of 71 specialist agents + MCP + token savings. Honest comparison of the layers, with the integration path spelled out.

By Kodelyth · updated · v2.30.0

Kodelyth ECC vs Continue.dev

Short version. Continue.dev is a config-driven open-source AI coding assistant for VS Code and JetBrains with excellent local- model support. Kodelyth ECC is a catalog toolkit — 71 specialist agents + MCP server + token savings — that installs into 12 AI IDEs. Different problems, same adjacent space. They can be combined via MCP today; a first-class integration is on ECC's roadmap.

What Continue.dev is

Continue.dev is an AI coding assistant you shape with configuration:

  • VS Code + JetBrains extension — IDE-integrated chat + autocomplete
  • Model-agnostic — OpenAI, Anthropic, Ollama, LM Studio, vLLM, many more
  • First-class local model support — among the best in the ecosystem
  • Context providers — pluggable sources that pull repo state into the chat (files, terminals, URLs, docs, MCP servers)
  • Slash commands — configurable in YAML
  • Open-source, Apache-2.0

The design bet: configurability. You write YAML to describe how your assistant should work, and Continue runs that assistant. Local models, custom context, custom commands — all declarative.

What ECC is

ECC is a catalog of named specialist agents with plain-language intent routing. You don't configure what the assistant does per-session; you describe your problem, and routing picks the right specialist from a fixed catalog of 71. Plus:

  • 196 skills — granular workflows the agent dispatches when a task matches
  • 104 slash commands — including 8 parallel-fire multi-agent commands
  • Universal MCP server — the full catalog over stdio JSON-RPC
  • RTK + Terse — input + output token compression (55-65% combined)
  • Memory Core — local BM25 recall, git-remote-identified, redacts secrets
  • Super Agent — autonomous orchestrator for multi-step objectives

The design bet: catalog + routing. You don't configure; you just ask.

How they stack

LayerContinue.devECC
VS Code + JetBrains chat UI✓— (ECC rides your tool's UI)
YAML configuration of models + commands✓— (ECC ships a fixed catalog)
First-class local-model support (Ollama, LM Studio, vLLM)✓— (model-agnostic, not local-specific)
Autocomplete in-editor✓—
Context providers (pluggable)✓—
Specialist agents (71), named + intent-routed—✓
Parallel multi-agent commands (/team-review, /devil-mode, /debug-blitz)—✓
Universal MCP server exposing a 71-agent catalog—✓
Local memory keyed by git remote—✓
Shell-output token compression (RTK)—✓
AI-reply token compression (Terse)—✓
Codebase AST graph (158 languages)—✓

Only one row genuinely conflicts: UI layer. Continue.dev is the chat UI itself (VS Code + JetBrains); ECC rides whatever UI your AI tool already provides. If you live in Continue.dev, you've picked your UI.

The MCP bridge (works today)

Continue.dev supports MCP context providers — you can point Continue.dev at any MCP server and its tools + resources become available in-chat. Since ECC ships a compliant MCP server, this works today:

  1. In one terminal: kodelythecc mcp (starts ECC's MCP server on stdio).
  2. In Continue.dev config: add a context provider that spawns kodelythecc mcp as a subprocess (Continue.dev's MCP docs cover the syntax).
  3. Continue.dev chats now have access to ECC's 71 agents, 196 skills, 104 commands, 15 rules, and local Memory Core via the kodelyth-ecc MCP namespace.

No ECC install target, no config merge — just an MCP server pointer in your Continue config.

Can you install ECC into Continue.dev directly?

Not yet. ECC's --target list currently covers 12 IDEs (Claude Code, Cursor, Windsurf, Codex, Antigravity, OpenCode, Cline, Roo Code, Aider, Kimi, Gemini CLI, Kiro). Continue.dev is a planned addition.

The reason it hasn't shipped yet: Continue.dev's config is YAML, and most ECC targets write JSON. A safe merge story that never clobbers an existing config.yaml needs its own pass. If you want this sooner, drop a thumbs-up on the ECC issue tracker.

When to pick which

Pick Continue.dev when:

  • You want to run local models (Ollama, LM Studio, vLLM) first-class.
  • You live in VS Code or JetBrains and want a chat UI tailored to it.
  • You're willing to configure your assistant in YAML — and want the control that gives.
  • You need in-editor autocomplete (ECC doesn't do autocomplete; it lives at the chat layer).

Pick Claude Code / Cursor / Windsurf + ECC when:

  • You want specialist agents selectable by plain language, without configuring anything.
  • You want /team-review, /devil-mode, /debug-blitz out of the box.
  • You want RTK + Terse token savings layered under whatever model you run.
  • You want the same catalog available across 12 AI IDEs.

Use both when:

  • You use Continue.dev for in-editor autocomplete with a local model, and point it at the ECC MCP server for specialist chat.

Bottom line

Continue.dev is an excellent config-driven assistant, especially for local-model workflows. ECC is a catalog toolkit with intent routing. They are not mutually exclusive — the MCP bridge works today, and a first-class Continue.dev target is on the way.

# ECC's MCP server — Continue.dev can consume this via an MCP context provider
npm i -g kodelyth-ecc
kodelythecc mcp
Last updated: 2026-11-11T00:00:00.000Z · v2.30.0