ECC

Quick verdict: ECC is a serious toolbox for people who want coding agents to work with a repeatable engineering process instead of improvising from one prompt to the next. It bundles agents, skills, rules, hooks, memory, planning, review, testing, and security checks into one open-source system. The catch is equally important: Claude Code is the primary stable target, other harnesses have uneven feature parity, and installing every component can add more context and automation than a small project needs.

ECC describes itself as an agent harness performance optimization system. In practical terms, it gives AI coding tools a reusable operating method: plan the work, test assumptions, implement, review from a fresh perspective, verify the result, remember useful context, and turn repeated successes into reusable skills. It does not provide a model of its own. You bring Claude Code, Codex, Cursor, OpenCode, Kimi Code, or another supported harness, then choose the ECC pieces that fit your workflow.

What is ECC?

ECC is best understood as a configurable engineering layer around an AI coding agent. The current README lists 67 specialized agents, 282 skills, and 94 maintained command shims, alongside rules, hooks, memory tools, continuous learning, and AgentShield. Those numbers are useful for showing the breadth of the repository, but the value is not in loading all of them. The practical benefit is being able to select a tested workflow for planning, TDD, security review, build repair, architecture, documentation, or repository research without rewriting the process in every conversation.

The project is actively moving. At the time of this review, the package on the main branch identified itself as version 2.2.0, while the latest published GitHub release was v2.1.0 from July 27, 2026. That release introduced Plan Canvas, a Kimi Code target, self-hosted model guidance, and more supply-chain hardening. Read the current setup notes before installing because the source tree can be ahead of the latest packaged release.

Key features

• Reusable engineering workflows: skills and agents cover planning, testing, implementation, code review, security, architecture, documentation, research, and operational work.
• Hooks and rules: optional automation can save session state, suggest compaction, check edits, enforce project conventions, and run verification steps around tool events.
• Plan Canvas: an agent can open a local browser page where you annotate a plan, chat beside it, review Mermaid diagrams, and approve or request changes.
• Memory and learning: session summaries, a portable Markdown Memory Vault, and opt-in instinct workflows help preserve useful context across sessions and harnesses.
• Security tooling: AgentShield scans instructions, hooks, MCP configuration, permissions, secrets, and agent files, while GateGuard checks destructive shell patterns.
• Multiple harnesses: the repository includes paths for Claude Code, Codex, Cursor, OpenCode, Kimi Code, Gemini, Zed, OpenClaw, Hermes, and others, with clearly documented limits.

Plan Canvas is a good example of ECC’s practical approach. Instead of asking you to describe a change to a long terminal plan, it turns review into a visual loop. You can point at a section, attach feedback, and map the final decision back to the agent’s confirmation gate. It remains a local, loopback-only browser interface and communicates through a plain CLI and JSON protocol rather than depending on one model.

What makes it different

Many agent repositories are either prompt collections or one-off demos. ECC is broader: it tries to manage the full operating environment around the agent. Skills hold reusable procedures, agents provide scoped roles, rules carry selected standards, hooks react to events, and memory preserves context. The repository also exposes dry-run, doctor, repair, uninstall, and selective-install paths, which matters when a tool can write into several different agent configuration directories.

The security posture is unusually explicit. ECC warns that hooks can execute commands, MCP servers can hold credentials, and project instructions can enter an agent’s context. AgentShield offers static checks and CI-friendly output, but it is a guardrail rather than proof that a configuration is safe. You should still inspect every enabled hook, MCP server, permission, and third-party skill, install only from official channels, and keep credentials outside prompts and repository files.

How to use ECC

You need Node.js 18 or newer and a supported coding harness. Start with one installation path only. For the guided Claude Code setup, the project recommends:

npx ecc-universal setup

If you want to configure more than one supported harness in a reviewed flow, use the multi-harness wizard:

npx ecc-universal install --guided

Review the proposed target, scope, profile, and hook choices before approving writes. Begin with a minimal or core profile, add only the language rules and skills you need, and use a dry run where the selected adapter supports it. Do not combine a full manual install with the plugin path, and do not layer the Codex sync flow over the marketplace plugin. Duplicate installs can register the same skills, rules, or hooks twice.

After installation, test one real repository task: ask the agent to produce a plan, make a small change, run the project’s tests, and review the diff. Then inspect which ECC components were actually used. On Windows, the core CLI works, but some observer, memory-vault, shell, GAN, and orchestration features still need WSL, Git Bash, Python, or have documented native limitations. Codex support is useful but partial; the current support matrix treats the sync or repo path as more reliable than the experimental marketplace package.

Best use cases

• Teams that want the same planning, testing, review, and verification habits across repositories.
• Developers who repeatedly rebuild similar agent instructions and want reusable skills instead.
• Large codebases where scoped agents and selective rules can reduce ad hoc prompting.
• Security-conscious users who want an auditable layer around hooks, MCP servers, secrets, and permissions.
• People comparing several coding harnesses who need a shared workflow vocabulary, even when runtime parity is incomplete.

ECC is less attractive for a quick one-file edit, a first experiment with coding agents, or anyone who wants a zero-maintenance hosted service. The catalog is large, so installing the full profile without a clear goal can increase context use and create more configuration to audit. It also does not remove the need to review generated code, run tests, protect secrets, and understand what an agent is allowed to execute.

Pricing and license

The ECC repository and ecc-universal package are open source under the MIT License. You can use, modify, and redistribute the software while preserving the copyright and license notice. The open-source project itself has no subscription fee, although your chosen coding agent, model API, local compute, or supporting services may cost money.

ECC also offers a separate hosted ECC Pro and GitHub App product. The project website lists a free public-repository path and paid private-repository plans starting at $19 per seat per month at research time. That commercial service is optional and should not be confused with the MIT-licensed repository. Check the current pricing page before budgeting because hosted plan details can change.

My take

ECC is one of the more complete attempts to turn agent-assisted coding into an engineering system rather than a bag of clever prompts. I like the selective installation model, the honest support matrix, Plan Canvas, and the insistence that memory remains unreviewed context rather than executable policy. The project also documents failure modes such as duplicate hooks, incomplete adapter parity, and context bloat instead of hiding them.

My practical recommendation is to start small. Pick one harness, one real repository, a minimal profile, and two or three workflows you already understand. Measure whether ECC improves review quality and repeatability before enabling memory, continuous learning, extra MCP servers, or a large rule catalog. Used selectively, it can make a coding agent more disciplined. Installed wholesale, it can become another complex system you have to maintain.