# Kodelyth Ecc

> 70 agents · 194 skills · 97 commands · 22+ hooks · semantic intent routing · self-learning memory · MCP server. Claude Code, Windsurf, Cursor, Codex, Antigravity, Cline, Roo Code, Aider, Kimi, Gemini CLI. MIT.

- **Type:** MCP server
- **Install:** `agentstack add mcp-sifxprime-kodelyth-ecc`
- **Verified:** Pending review
- **Seller:** [sifxprime](https://agentstack.voostack.com/s/sifxprime)
- **Installs:** 0
- **Category:** [AI & ML](https://agentstack.voostack.com/c/ai-and-ml)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [sifxprime](https://github.com/sifxprime)
- **Source:** https://github.com/sifxprime/kodelyth-ecc
- **Website:** https://www.npmjs.com/package/kodelyth-ecc

## Install

```sh
agentstack add mcp-sifxprime-kodelyth-ecc
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

[](https://www.npmjs.com/package/kodelyth-ecc)
[](https://www.npmjs.com/package/kodelyth-ecc)
[](https://github.com/sifxprime/kodelyth-ecc/stargazers)
[](LICENSE)

**Kodelyth ECC** is a production-grade AI coding toolkit — **70 specialist agents (incl. an 8-agent devil-mode adversarial crew), 194 skills, 97 commands**, a god-tier **semantic intent-routing system**, local self-learning memory, MCP server, swarm orchestrator, and an observability dashboard — all local, zero telemetry.

Works with **Claude Code**, **Windsurf**, **Cursor**, **Codex CLI**, **Google Antigravity**, **OpenCode**, **Cline**, **Roo Code**, **Aider**, **Kimi**, and **Gemini CLI**.

> No telemetry. No cloud. Just rules, agents, skills, MCP server, and your own private memory store — all on your disk. The local dashboard gives you full visibility without sending anything anywhere.

---

## Why ECC ≠ Another Agent Collection

Most "AI agent kits" are folders of markdown files you have to remember the names of. **ECC is infrastructure** — a layered system where intent routing, compound memory, parallel orchestration, and quality hooks all reinforce each other.

```
You:   "I've been staring at this NullPointerException for two hours,
        I'm losing my mind."

AI:    → Routing to debug-detective (your error + frustration matches the bug-tracking signal)

       That kind of bug is exhausting — let's trace it properly so we
       fix the root cause, not the symptom.

       First, can you share the full stack trace and...
```

You never typed `use debug-detective`. You didn't have to. The toolkit read the intent, picked the specialist, and announced the routing. Next time you can invoke it directly — but you don't have to remember names to get senior-grade help.

### The Layer Stack

| Layer | What it does | Other kits |
|---|---|---|
| **Intent routing** | Plain-language → right specialist via 10-tier priority rules | Mostly missing — you memorize names |
| **70 agents** | Specialists with playbooks, severity calibration, real commands | Often persona-only ("you are a senior engineer...") |
| **194 skills** | Domain knowledge files agents read on demand | Rarely separated from agents |
| **97 commands** | Slash workflows (`/tdd`, `/devil-mode`, `/team-review`) | Limited or none |
| **8 parallel commands** | Fire 3-8 agents simultaneously, aggregate results | Rare |
| **Compound memory** | BM25 local recall + auto-inject + project lessons | Cloud-only or absent |
| **22+ hooks** | Quality gates, secret scan, project-DNA detection | Often missing |
| **11 IDE platforms** | Claude Code, Windsurf, Cursor, Codex, Antigravity, OpenCode, Cline, Roo Code, Aider, Kimi, Gemini CLI (13 install targets) | 1-2 platforms typical |
| **Zero telemetry** | Everything stays on your disk; verifiable | Many kits phone home |

### Quick Comparison vs Other Kits

| Feature | **Kodelyth ECC** | `agency-agents` | `awesome-claude-agents` | Generic prompt libs |
|---|---|---|---|---|
| Specialist agents | **70** | ~30 | ~20 | Varies |
| Skills as separate layer | ✅ 194 | ❌ | ❌ | ❌ |
| Slash commands | ✅ 97 | Some | Some | ❌ |
| **Parallel multi-agent commands** | ✅ 8 (incl. `/devil-mode`) | ❌ | ❌ | ❌ |
| **Intent routing (plain language → agent)** | ✅ 10-tier rule | ❌ | ❌ | ❌ |
| **Local BM25 self-learning memory** | ✅ | ❌ | ❌ | ❌ |
| **Compound learning from corrections** | ✅ `tasks/lessons.md` | ❌ | ❌ | ❌ |
| **Adversarial / red-team agents** | ✅ 8 (devil-mode) | ❌ | ❌ | ❌ |
| Quality hooks | ✅ 22+ | Some | ❌ | ❌ |
| IDE platforms | **11** (Claude Code, Windsurf, Cursor, Codex, Antigravity, OpenCode, Cline, Roo Code, Aider, Kimi, Gemini CLI) | 1-2 | 1 | Varies |
| Telemetry | ❌ none | Varies | ❌ | Varies |
| Test coverage | ✅ 373 tests | ❌ | ❌ | ❌ |
| Distributed via | `npx`, curl, clone | Manual | Manual | Manual |

---

## Install

### Option 1 — npx from npm (recommended, any platform)

```bash
npx kodelyth-ecc                              # Claude Code (default)
npx kodelyth-ecc --target windsurf-project    # Windsurf (per-project)
npx kodelyth-ecc --target windsurf-home       # Windsurf (global)
npx kodelyth-ecc --target cursor-project      # Cursor IDE
npx kodelyth-ecc --target codex-home          # Codex CLI
npx kodelyth-ecc --target antigravity         # Google Antigravity
npx kodelyth-ecc --target opencode            # OpenCode
npx kodelyth-ecc --target cline               # Cline (VS Code)
npx kodelyth-ecc --target roocode             # Roo Code (VS Code)
npx kodelyth-ecc --target aider               # Aider terminal agent
npx kodelyth-ecc --target kimi                # Kimi Code
npx kodelyth-ecc --target gemini-project      # Gemini CLI (project)
npx kodelyth-ecc --target gemini-home         # Gemini CLI (global)
```

Node.js 18+ required. [Download Node](https://nodejs.org) if you don't have it.

### Platform support at a glance

Feature depth varies by platform — hooks are a Claude Code native format, and some platforms have no agent/command concept:

| Platform | Agents | Skills | Commands | Hooks | Rules |
|---|---|---|---|---|---|
| **Claude Code** | ✓ 70 | ✓ 194 | ✓ 97 | ✓ 22+ | ✓ |
| **Roo Code** | ✓ | ✓ | ✓ | — | ✓ |
| **Codex CLI** | ✓ | ✓ | ✓ | — | ✓ |
| **Aider** | ✓ | ✓ | ✓ | — | ✓ |
| **Kimi** | ✓ | ✓ | ✓ | — | ✓ |
| **Windsurf** | ✓ | ✓ | — | — | ✓ |
| **Antigravity** | ✓ | partial | ✓ | — | ✓ |
| **Gemini CLI** | ✓ | ✓ | — | — | ✓ |
| **Cursor** | — | ✓ | — | — | ✓ |
| **Cline** | ✓ | — | ✓ | — | ✓ |
| **OpenCode** | — | — | — | — | ✓ |

Hooks use Claude Code's JSON settings format — no equivalent exists on other platforms. Cursor reads rules and skills from `.cursor/`; its agent system uses a different format not yet compatible with ECC agents.

### Memory & dashboard reality per IDE

Memory storage is a single shared file at `~/.kodelyth/memory/memories.jsonl` — every IDE on the same machine reads and writes the **same** memories. The only thing that varies is *how* memories surface:

| Platform | Auto-recall on every prompt | Auto-capture on success | Manual recall via MCP tool | Dashboard "Live IDE activity" |
|---|---|---|---|---|
| **Claude Code** | ✓ (hook) | ✓ (hook) | ✓ | ✓ Claude session files |
| **Windsurf** | — | — | ✓ `recall_memory` | ✓ Windsurf + Windsurf-Next state |
| **Cursor** | — | — | ✓ `recall_memory` | ✓ workspace storage dirs |
| **Codex CLI** | — | — | ✓ `recall_memory` | — |
| **Antigravity** | — | — | ✓ `recall_memory` | ✓ `.agent/` in cwd |
| **Roo Code / Aider / Kimi / Cline / Gemini CLI / OpenCode** | — | — | ✓ if MCP-capable | — |

What this means in practice:
- A memory captured in **Claude Code** is recall-able from every other IDE the same day — the file is shared.
- In **Windsurf / Cursor / Codex / Antigravity**, the AI does NOT auto-fire memory recall; the `rules/common/memory-protocol.md` rule (installed automatically) tells the AI to call the `recall_memory` MCP tool proactively at the start of substantive prompts.
- The dashboard's **Sessions → Live IDE activity** tab surfaces session files for Claude Code, Windsurf, Windsurf-Next, Cursor, and Antigravity. Add custom paths via the `KODELYTH_EXTRA_IDE_WATCH` env var (comma-separated).

```bash
# Watch additional paths in the dashboard
export KODELYTH_EXTRA_IDE_WATCH="$HOME/my-agent-logs,$HOME/other-tool/state"
npx kodelyth-ecc dashboard
```

### Option 2 — npx from GitHub (always latest commit)

```bash
npx github:sifxprime/kodelyth-ecc
```

Same `--target` flags work.

### Option 3 — curl (macOS / Linux only)

```bash
curl -fsSL https://raw.githubusercontent.com/sifxprime/kodelyth-ecc/main/install.sh | bash
```

With a target:

```bash
curl -fsSL https://raw.githubusercontent.com/sifxprime/kodelyth-ecc/main/install.sh | bash -s -- --target windsurf-project
```

### Power Bundles

Pre-configured for who you actually are:

```bash
npx kodelyth-ecc --bundle indie-hacker    # Solo founder / SaaS — ship fast, validate, harden
npx kodelyth-ecc --bundle red-team        # Security engineer — devil-mode + adversarial workflows
npx kodelyth-ecc --bundle enterprise      # Compliance / audit team — SBOM, license, supply chain
```

Each bundle installs the full ECC toolkit (all 70 agents, 194 skills, 97 commands, 22+ hooks), adds a `BUNDLE.md` cheat sheet, and biases the AI toward audience-fit workflows on every session.

Combine with any target:

```bash
npx kodelyth-ecc --bundle red-team --target windsurf-project
npx kodelyth-ecc --bundle enterprise --target codex-home
npx kodelyth-ecc --bundle indie-hacker --target antigravity
```

### Option 4 — Clone and run

```bash
git clone https://github.com/sifxprime/kodelyth-ecc.git
cd kodelyth-ecc

# macOS / Linux
./install.sh                              # Claude Code (default)
./install.sh --target windsurf-project    # Windsurf

# Windows (PowerShell)
.\install.ps1
.\install.ps1 -Target windsurf-project
```

---

## MCP Server — Universal Adapter

Run ECC as a Model Context Protocol server and consume it from Claude Desktop, LangGraph, AutoGen, CrewAI, OpenAI Agents SDK, Cursor, Windsurf — anything that speaks MCP.

```bash
npx kodelyth-ecc mcp                         # stdio JSON-RPC server
```

What it exposes (all local, zero telemetry):

- **16 tools** — `route_intent`, `recall_memory`, `capture_memory`, `list_agents`, `get_skill`, `audit_skill_match`, …
- **6 prompts** — full intent routing rule, agents/skills/commands overviews, handoff chains, devil-mode
- **365 resources** — every agent, skill, command, rule, and bundle addressable via `kodelyth://...` URIs

Drop into Claude Desktop in 30 seconds:

```jsonc
// claude_desktop_config.json
{
  "mcpServers": {
    "kodelyth-ecc": {
      "command": "npx",
      "args": ["-y", "kodelyth-ecc", "mcp"]
    }
  }
}
```

Full reference: [`docs/mcp.md`](docs/mcp.md).

---

## How Intent Routing Works

The toolkit ships with a single rule file (`rules/common/agent-intent-routing.md`) that the AI loads automatically on every session. It maps **what you say** to **the right specialist agent** across 10 priority tiers.

### Two activation paths

**1. Explicit** — type it directly:
```
use debug-detective
@code-reviewer
invoke security-reviewer
```

**2. Implicit** — just describe your problem; the AI routes you:

| What you write | Auto-routed to |
|---|---|
| "I'm stuck, no idea where to start" | `kodelyth-advisor` |
| "I've been debugging this for hours" | `debug-detective` |
| "nothing works, driving me crazy" | `debug-detective` |
| "Should I use Context or Zustand?" | `pair-programmer` |
| "help me build a todo app" | `/project-launch` |
| "I have this idea for a SaaS dashboard" | `/project-launch` |
| "I'm starting a new side project" | `/project-launch` |
| "can you review my code?" | `code-reviewer` or `/team-review` |
| "review my project before I deploy" | `/team-review` |
| "is my project ready to ship?" | `/team-review` |
| "my site looks plain, needs visuals" | `image-architect` |
| "I need an OG image for my app" | `image-architect` |
| "remember we always use pnpm here" | `/lessons` |
| "Build failed on Vercel" | `build-error-resolver` |
| "Is this JWT signing secure?" | `security-reviewer` |
| "Why is this so slow?" | `performance-optimizer` |
| "Plan the v2 migration" | `planner` + `migration-guide` |
| "Tests pass locally but fail on CI" | `flake-hunter` + `env-debugger` |
| "I lost my commits after `reset --hard`" | `git-rescue` |
| "npm install is failing" | `dependency-doctor` |
| "Cut a 1.4 release" | `release-captain` |
| "Add accessibility to this form" | `ux-reviewer` |
| "Open-source this project" | `opensource-forker` (chain) |
| [paste code with no text] | `code-reviewer` |
| [paste stack trace with no text] | `debug-detective` |

The AI **always announces** which agent is taking over (`→ Routing to `) and **always teaches** you the explicit form for next time (`Tip: type "use "`). No silent personality changes.

### Multi-agent chains

Real problems span multiple specialties. ECC ships standard handoff chains:

```
pair-programmer  →  tdd-guide  →  code-reviewer  →  security-reviewer
(approach)         (write tests)  (review impl)     (auth, validation)
```

```
debug-detective  →  tdd-guide        →  refactor-cleaner
(root cause)        (regression test)   (cleanup)
```

```
opensource-forker  →  opensource-sanitizer  →  opensource-packager  →  release-captain
(clean fork)          (strip secrets)            (README, license)        (cut v0.1.0)
```

See `skills/agent-handoff/SKILL.md` for the full handoff protocol and standard chains.

---

## Parallel Agents — 8 Commands, Minutes Not Hours

Eight commands fire multiple specialist agents simultaneously and aggregate their results into a single structured report.

| Command | Agents Fired | Time Saved |
|---|---|---|
| `/project-launch` | architect + pair-programmer + security-reviewer + tdd-guide + ux-reviewer | 45 min → 10 min |
| `/team-review` | code-reviewer + security-reviewer + performance-optimizer + api-guardian | 60 min → 15 min |
| `/security-audit` | security-reviewer + dependency-doctor + api-guardian | 30 min → 8 min |
| `/debug-blitz` | debug-detective + silent-failure-hunter + env-debugger | 60 min → 15 min |
| `/refactor-sprint` | refactor-cleaner + code-simplifier + type-design-analyzer + tdd-guide | 45 min → 12 min |
| `/pre-release` | release-captain + security-reviewer + code-reviewer | 30 min → 8 min |
| `/onboard` | code-explorer + architect + doc-updater | 45 min → 12 min |
| `/devil-mode` | 8 adversarial agents (see below) | Hours → 20 min |

Each command waits for all agents to complete, then returns a single **Team Review Report** with findings bucketed by severity: CRITICAL → HIGH → MEDIUM → LOW.

---

## Devil Mode — 8 Adversarial Agents

8 adversarial agents that read your codebase the way an attacker would. Fire them in parallel with `/devil-mode`:

```
/devil-mode --pre-public    # before going open-source — full secret/license/IP sweep
/devil-mode --pre-launch    # before launch — adds AI red-team + chaos planning
/devil-mode --all           # all 8 adversarial agents in parallel
```

The crew: `prompt-injection-hunter`, `supply-chain-auditor`, `secret-hunter`, `license-violation-finder`, `jailbreak-tester`, `code-stealer-detector`, `backdoor-hunter`, `chaos-engineer`. Each ships with real bash-grep patterns, severity calibration, and remediation playbooks — not theatrical personas.

---

## Live Dashboard — Full Visibility, Localhost Only

**You have a working, real-time dashboard.** One command launches it:

```bash
npx kodelyth-ecc dashboard
# Opens http://127.0.0.1:5747 in your browser
```

What's inside:

| Tab | What you see |
|---|---|
| **Overview** | Agent count, memory stats, session count, recent activity |
| **Memory** | Browse, search, and manage your local BM25 memory store |
| **Evolve** | Self-improving memory — review AI-proposed refinements |
| **Catalog** | Full searchable index of all 70 agents, 194 skills, 97 commands |
| **Sessions** | **Live IDE activity** (Claude Code, Windsurf, Windsurf-Next, Cursor, Antigravity) + orchestration/swarm sessions |

Real-time:
- SSE push every 3 seconds, only when at least one browser tab is connected (zero CPU otherwise)
- Watches memory writes, evolve signals, token-budget changes, and IDE session files
- "Last activity" auto-updates without a page refresh
- Set `KODELYTH_EXTRA_IDE_WATCH=path1,path2` to watch additional paths

Security design:
- **GET-only** — no write endpoints accessible from the UI
- **Localhost-bound** — refuses connections from non-localhost Host headers (DNS rebinding protection)
- **Hardened headers** — `Content-Security-Policy`, `X-Frame-Options`, `X-Content-Type-Options` on every response
- **Zero telemetry** — no external network calls ever leave your machine
- **Max 10 SSE clients** — connection cap prevents resource exhaustion

Full reference: [`docs/dashboard.md`](docs/dashboard.md).

---

## Kodelyth Memory — Local Self-Learning

The first time you s

…

## Source & license

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

- **Author:** [sifxprime](https://github.com/sifxprime)
- **Source:** [sifxprime/kodelyth-ecc](https://github.com/sifxprime/kodelyth-ecc)
- **License:** MIT
- **Homepage:** https://www.npmjs.com/package/kodelyth-ecc

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

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** yes
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: flagged — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/mcp-sifxprime-kodelyth-ecc
- Seller: https://agentstack.voostack.com/s/sifxprime
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.