ECC (affaan-m) — Summary

ECC (Everything Claude Code) by affaan-m is the most comprehensive multi-tool agent harness in this batch with 193,231 stars — the top-starred framework overall. It ships 61 agents, 246 skills, 76 legacy command shims, a Tkinter desktop dashboard (ecc_dashboard.py), a Rust control-plane prototype (ecc2/), a SQLite state store, a manifest-driven selective installer (install-plan.js/install-apply.js), hooks for PreToolUse/PreCompact/SessionStart/Stop events, a security scanner integration (AgentShield), PM2-based multi-agent orchestration, Git worktree parallelization, and a GitHub App (ecc-tools) with a $19/seat/mo Pro tier. It targets 8 AI tools: Claude Code, Codex, Cursor, OpenCode, Gemini, Zed, GitHub Copilot, and more. The self-description as "harness-native operator system" and the "harness performance optimization system" branding make this the most explicit meta-commentary on harness engineering in the catalog. Differs from seeds: dwarfs all seeds in scale — 246 skills vs superpowers' 14, 61 agents vs BMAD's 6. Most closely resembles claude-flow (Archetype 3: MCP-anchored, hive-mind, multi-agent) in architecture ambition but delivers value primarily through the skills/agents layer (Archetype 1) rather than an MCP server. The ECC v2.0 Rust control plane in ecc2/ represents an emerging Archetype 5 (dedicated runtime) trajectory.

ECC (affaan-m) — Overview

Origin

GitHub: https://github.com/affaan-m/ECC
Stars: 193,231
License: MIT
Language: JavaScript (primary), Shell, TypeScript, Python, Go, Java, Perl
Last commit: 2026-05-25
npm packages: ecc-universal, ecc-agentshield
GitHub App: ecc-tools (150 installs, $19/seat/mo Pro tier)
Anthropic Hackathon Winner

Philosophy

From README:

"The harness-native operator system for agentic work. Not just configs. A complete system: skills, instincts, memory optimization, continuous learning, security scanning, and research-first development. Production-ready agents, skills, hooks, rules, MCP configurations, and legacy command shims evolved over 10+ months of intensive daily use building real products."

"Works across Claude Code, Codex, Cursor, OpenCode, Gemini, Zed, GitHub Copilot, and other AI agent harnesses."

Key Milestones (from changelog)

• v1.8.0 "Harness-first release" — explicit rebranding as harness performance system
• v1.9.0 — Selective install architecture with manifest-driven pipeline
• v2.0.0-rc.1 — ECC 2.0 alpha Rust control plane (ecc2/), dashboard GUI, operator workflows

Key Design Decisions

1. Never stack install methods: plugin install + manual installer = broken setup.
2. Selective install: manifest-driven pipeline installs only what you need.
3. OSS stays free: MIT-licensed forever; Pro is the GitHub App for private repos.
4. Hook profiles: ECC_HOOK_PROFILE=minimal|standard|strict and ECC_DISABLED_HOOKS for runtime gating.
5. Instinct-based continuous learning: session observations → instinct files → skill evolution.
6. Cross-harness parity: consistent behavior across 7+ AI tools.

ECC (affaan-m) — Architecture

Distribution

Multiple paths (NEVER stack):

# Primary path (Claude Code plugin)
/plugin marketplace add https://github.com/affaan-m/ECC
/plugin install ecc@ecc

# Manual install (fallback, do not combine with plugin)
./install.sh --profile full
.\install.ps1 --profile full
npx ecc-install --profile full

# Selective component install
npx ecc consult "security reviews" --target claude
npx ecc install --profile minimal --target claude --with capability:security

# Rules only (after plugin install)
cp -R rules/common ~/.claude/rules/ecc/
cp -R rules/typescript ~/.claude/rules/ecc/

Directory Tree (selected)

ECC/
├── .agents/                 # Agent definitions (61)
├── .claude-plugin/          # Claude Code plugin manifest
├── .claude/                 # Claude Code settings
├── .codex-plugin/           # Codex plugin
├── .codex/                  # Codex settings
├── .cursor/                 # Cursor settings
├── .gemini/                 # Gemini settings
├── .opencode/               # OpenCode settings
├── .kiro/                   # Kiro settings
├── agents/                  # Agent markdown files (61)
├── commands/                # Legacy commands (76 shims)
├── contexts/                # Context files
├── ecc2/                    # Rust control plane (alpha)
├── hooks/
│   ├── hooks.json           # Hook definitions
│   └── memory-persistence/  # Session memory persistence scripts
├── integrations/            # Tool integrations
├── manifests/               # Install manifests
├── mcp-configs/             # MCP server configurations
├── plugins/                 # Plugin system
├── rules/
│   ├── common/              # Common rules
│   ├── typescript/          # TypeScript rules
│   ├── python/              # Python rules
│   ├── golang/              # Go rules
│   ├── java/                # Java rules
│   ├── php/                 # PHP rules
│   ├── perl/                # Perl rules
│   ├── kotlin/              # Kotlin rules
│   ├── cpp/                 # C++ rules
│   └── rust/                # Rust rules
├── scripts/                 # Build and lifecycle scripts
├── skills/                  # 246 skills
├── src/                     # Source code
├── ecc_dashboard.py         # Tkinter desktop dashboard
├── SOUL.md                  # Agent identity
├── RULES.md                 # Core rules
└── WORKING-CONTEXT.md       # Session context

Required Runtime

• Node.js (for installer and hooks)
• Python (for dashboard and scripts)
• Rust (for ecc2/ — alpha only)

Supported Tools

Claude Code, Codex CLI, Codex app, Cursor, OpenCode, Gemini CLI, Zed, GitHub Copilot

ECC (affaan-m) — Components

Skills (246)

Organized by domain. Selected highlights:

Agents (61)

Commands (76 legacy shims)

Maintained for backward compatibility — route to new skill equivalents.

New harness commands (v1.8.0+):

• /harness-audit
• /loop-start
• /loop-status
• /quality-gate
• /model-route
• /ecc:plan (namespaced form for plugin install)

PM2 commands (v1.4.0+):

• /pm2
• /multi-plan
• /multi-execute
• /multi-backend
• /multi-frontend
• /multi-workflow

Hooks (multiple per event)

Events covered:

• PreToolUse (Bash, Write, Edit, MultiEdit, *)
• PreCompact
• SessionStart (root fallback)
• Stop (session summaries)

Hook profiles: ECC_HOOK_PROFILE=minimal|standard|strict

Specific hooks:

• pre:bash:dispatcher — quality, tmux, push, GateGuard checks
• pre:write:doc-file-warning — non-standard documentation file warning
• pre:edit-write:suggest-compact — suggest manual compaction at intervals
• pre:observe:continuous-learning — capture tool use for continuous learning (async)
• pre:governance-capture — secrets/policy violation detection
• pre:config-protection — block modifications to linter/formatter config
• pre:mcp-health-check — MCP server health before execution
• pre:edit-write:gateguard-fact-force — block first Edit per file, demand investigation

Rules (10 language packs)

common, typescript, python, golang, java, php, perl, kotlin, cpp, rust

MCP Configurations

.mcp.json — pre-configured MCP server references

Dashboard (Tkinter)

ecc_dashboard.py — Python Tkinter desktop app:

• Dark/light theme toggle
• Font customization
• Agent and skill catalog browser
• Session management

Rust Control Plane (alpha, ecc2/)

Commands: dashboard, start, sessions, status, stop, resume, daemon

ECC (affaan-m) — Uniqueness

differs_from_seeds

Dwarfs all seeds in scale: 246 skills vs superpowers' 14, 61 agents vs BMAD's 6. Primarily resembles superpowers (Archetype 1: skills-only behavioral framework) in daily operation but adds hooks, multi-model routing, PM2 orchestration, worktree isolation, desktop dashboard, Rust control plane, and a commercial GitHub App tier — making it an everything-included harness rather than a pure behavioral framework. The continuous learning via instinct files (extracting patterns from session observations) is closest in spirit to hermes-agent's learning loop but implemented as hooks rather than autonomous skill creation. The ecc2/ Rust control plane represents an emerging Archetype 5 (closed runtime) trajectory. Explicitly self-identifies the revfactory-harness as an L2 co-existing tool, positioning itself in a multi-framework ecosystem.

Most Distinctive Features

1. Scale: 246 skills + 61 agents is the largest skill/agent corpus in the catalog.
2. Cross-harness parity: consistent behavior across 8 AI tools — the only framework targeting this breadth.
3. Continuous learning via hooks: pre:observe hook extracts patterns asynchronously.
4. GateGuard: first-edit-per-file blocking pending investigation — unique enforcement pattern.
5. ecc2 Rust alpha: background daemon mode via Rust control plane — trajectory toward standalone runtime.
6. Commercial GitHub App: PR audit as SaaS product on top of OSS foundation.

Observable Failure Modes

1. Install complexity: "do not stack install methods" is a prominent warning — broken setups are common enough to warrant a repair command.
2. Observer loop re-entrancy: explicitly documented and defended against (5-layer guard in v1.9.0) — indicates real-world instability in hook execution.
3. Token overhead: 246 skills with auto-activation triggers could fire many skills per session.
4. Drift risk: 61 agents × 246 skills = 307 primitives to maintain; catalog count enforcement test exists but may not prevent semantic drift.