ECC: A Context-Saving Engineering System for Claude Code and Other Agent Harnesses
ECC supplies agent skills, security checks, memory patterns, and research workflows aimed at reducing wasted context during coding sessions.
At a glance
- What is it?
- ECC bundles 68 agents, 286 skills, memory patterns, and security checks into a plugin that aims to reduce wasted context during coding sessions. It is MIT-licensed, works best with Claude Code, and offers capability-limited adapters for other harnesses.
- Who is it for?
- Adopt ECC if you work primarily in Claude Code and want a pre-built engineering loop (plan, test, implement, review, verify, remember) without writing it into every prompt. It is also worth trying if you use Codex and need a supported sync path.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 1 day ago.
- What is it written in?
- Mainly JavaScript, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 15, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
What ECC Actually Solves
ECC addresses a specific pain: AI coding agents waste context window space by re-deriving the same engineering process every session. Instead of prompting the agent to plan, test, review, and remember each time, ECC installs a coordinated system once. The README states the core idea as 'Optimize the context window. Persist everything else.' That means the agent does not need to hold the entire workflow in its context; it can rely on installed skills, agents, and memory. The intended user is a developer who lives inside Claude Code and wants a repeatable engineering loop rather than ad-hoc prompting. The project bundles 68 agents, 286 skills, and 94 legacy command shims, plus hooks, rules, memory, and a security scanner called AgentShield. The value proposition is not about writing code faster in isolation; it is about reducing the overhead of process management so the agent can focus on the actual code.
The Architecture: Agents, Skills, Hooks, and Memory
The repository lays out a pipeline: plan, test, implement, review, verify, remember, improve. That pipeline is implemented as a collection of specialized agents for planning, review, build repair, security, architecture, and domain work. Skills are granular instructions or procedures the agent can invoke on demand. Hooks are plugin-managed, meaning they fire at specific points in the coding session without the user asking. Memory patterns let the agent persist what matters across sessions, which directly addresses the context-waste problem. The README mentions 'continuous learning' as part of the system. The design is modular: agents are separate from skills, and skills are separate from command shims. The legacy command shims suggest backward compatibility with an earlier version of ECC. The whole system is JavaScript, which fits the plugin ecosystem of Claude Code. The architecture is not a single binary; it is a set of files that get installed into the harness's plugin directory.
Installation: Two Paths, One Warning
The README gives two installation routes. The simplest is inside Claude Code, using the native plugin commands: '/plugin marketplace add https://github.com/affaan-m/ECC' followed by '/plugin install ecc@ecc'. That installs skills, agents, commands, and plugin-managed hooks. The README explicitly says to stop there and not also run a full manual install. The second path is through the npm package 'ecc-universal', which the release notes for v2.2.0 describe as 'guided package setup'. There is also a separate npm package called 'ecc-agentshield', presumably for the security scanner. The README includes a warning: install only from verified channels, listing the GitHub repository, the two npm packages, the GitHub App, the plugin slug 'ecc@ecc', and the website ecc.tools. It warns that third-party re-uploads may contain malware. That warning is unusual and suggests the project has seen impersonation attempts. For a security-conscious engineer, the install path is clear but must be followed exactly.
The Security Component: AgentShield and the GitHub App
ECC includes AgentShield, described in the README as 'security scanning'. The exact mechanism is not detailed in the README, but the name implies a shield that guards the agent's actions. The project also offers a GitHub App called 'ecc-tools', which is part of the ECC Pro tier. The pricing page mentions 'ECC Pro + GitHub App' with private repos starting at $19 per seat per month. The free tier installs the app for public repos. This is a commercial extension of the open-source core. The security scanning likely runs on the agent's changes or on the repository, but the README does not specify what AgentShield checks for. That is a gap: a user considering ECC for security must dig into the source or the docs to understand the coverage. The README does say the agents are specialized for security, so there is a security agent in addition to the scanner. The lack of detail means you should test it on a non-critical repo before trusting it.
Platform Support: Claude Code First, Others Limited
The README is direct: 'It works best with Claude Code today, has a supported Codex sync path, and provides capability-limited adapters for Cursor, OpenCode, Gemini, Zed, GitHub Copilot, Antigravity, Qwen, and other harnesses.' That is a clear warning against assuming feature parity. The release notes for v2.2.0 mention 'Antigravity 2.0' and a 'Nasiko CLI Bridge', so the adapter list is actively maintained. The v2.1.0 release notes mention 'Kimi Harness' and 'Self-Hosted Compute', which suggests support for Moonshot AI's Kimi and for running compute on your own infrastructure. For a user on Cursor or Copilot, the capability limits are the key constraint. The README points to a 'support status matrix' before assuming parity, but that matrix is not in the supplied text. The practical implication: if you are not on Claude Code or Codex, you are a second-class citizen. That is a deliberate trade-off, not an oversight.
Licensing, Maintenance, and the Single-Maintainer Risk
ECC is MIT-licensed, which is permissive and allows commercial use, modification, and redistribution. The README states 'OSS stays free' and that the repo is 'MIT-licensed forever'. The funding model is a mix of sponsorships and ECC Pro subscriptions. The README notes that 'a single maintainer ships weekly across 7 harnesses.' That is a maintenance risk: one person handles updates for Claude Code, Codex, Cursor, OpenCode, Gemini, Zed, Copilot, Antigravity, Qwen, and others. Weekly releases are fast, but they also mean breaking changes can land quickly. The release notes for v2.0.0 call it 'The Agent Harness Operating System', a big branding shift. The v2.2.0 release includes 'Guided Setup', which is a response to installation complexity. For a user, the maintenance cost is in tracking these weekly releases and verifying that your harness adapter still works. The license is clean, but the bus factor is one.
Alternatives and the Context-Waste Trade-off
The obvious alternative is to build your own agent workflow using raw prompts and custom scripts. That approach gives you full control but forces you to repeat the engineering process in every session, which is exactly what ECC tries to eliminate. Another alternative is to use a different plugin ecosystem, such as the built-in skills in Claude Code or a custom hook system. The difference in approach is that ECC centralizes the process into a single installable package, while a DIY setup is fragmented. A third alternative is to use a harness-specific tool like Codex's own memory features, but that locks you into one platform. ECC's value is in the breadth of agents and skills (68 and 286, respectively) and the memory layer. The trade-off is that you are trusting a single maintainer's design decisions. The README's own warning about unofficial mirrors indicates that the project is popular enough to attract impersonation, which is a sign of adoption but also a security concern.
What to Verify Before You Commit
Before adopting ECC, verify three things. First, confirm that the plugin source matches the official repository or the npm packages. The README's malware warning is not boilerplate; it is a direct instruction to check the source. Second, check the support status matrix for your specific harness. If you use Cursor or Copilot, expect missing features. Third, inspect what AgentShield actually scans. The README does not specify, so you need to read the source or the docs on ecc.tools. Also verify the memory pattern: does it store data locally or in the cloud? The README mentions 'self-hosted compute' in v2.1.0, which suggests you can run parts locally, but the default behavior is unclear. The release notes for v2.2.0 mention 'guided setup', so the installation is becoming easier, but that does not remove the need to understand what you are installing. The project is young (last push August 2026, v2.0.0 in June 2026), so the API may still be shifting. Test on a side project before using it on a production repo.
Editorial conclusion
Adopt ECC if you work primarily in Claude Code and want a pre-built engineering loop (plan, test, implement, review, verify, remember) without writing it into every prompt. It is also worth trying if you use Codex and need a supported sync path. Do not adopt it if you expect full feature parity across Cursor, Gemini, Zed, or Copilot, because the README explicitly says those adapters are capability-limited. Before installing, verify the plugin source against the official repository or the npm packages ecc-universal and ecc-agentshield, since the README warns about unofficial mirrors containing malware. For a single maintainer shipping weekly across seven harnesses, the maintenance cost is real: you must track release notes for each harness adapter and accept that some features may lag. The core judgement is that ECC is a serious context-optimization layer for Claude Code, not a universal agent framework.
Community notes