EGC — One Brain for Every AI Coding Agent

A local engine that gives Cursor, Claude Code, Copilot, Aider and 29 AI coding tools on your machine one shared memory, guardrails and live context — with zero configuration.

Source repo
Fmarzochi/EGC
Stars
★ 70
Last updated
today
License
Apache-2.0
Primary language
JavaScript

At a glance

How it runs
CLIMCP serverAgent plugin / skill
Works with
Universal · cross-platformCodex · Claude Code
Cost
Free, no paid service needed
Setup effort
Low · running in minutes
You'll need
npm/Node.js runtimegit (for Team Brain sync)Shell / CLINetwork accessLocal filesystemMCP Server
Typical use
Developers using both Cursor and Claude Code: a decision made in a Cursor tab is already known when you switch to a Claude Code terminal, with no re-explaining
Not a fit if
  • Developers who use none of the 29 supported AI coding tools
  • Teams wanting a hosted, multi-tenant memory service
  • Users of tools without hook surfaces, e.g. Auggie, who need full Guardian command guardrails
Website
fmarzochi.github.io/EGCSite ↗ set on GitHub
Maintenance
Commits in the last 30 dayslast commit 2026-11-21
Source review
76/100 · Good

What does this agent do, and when should you use it?

EGC (Extended Global Context) is a local-first runtime for AI coding tools. Install it once and every supported tool on your machine — Cursor, Claude Code, Codex, Copilot, Aider and more — shares one encrypted memory, one noise filter, and one live bus so open sessions can see each other. egc install detects your tools, registers two local MCP servers in each, writes the memory protocol every agent reads, and sets up the Token Crusher. Memory lives in ~/.egc, encrypted with AES-256-GCM, kept per project and branch, and never committed to your project's git repository. The engine has four faculties: Memory (shared learning across agents), Session Mesh (open sessions that see each other), Guardian (a background safety layer in front of commands) and Token Crusher (up to 90% output compression). For cross-machine sync, the optional Team Brain pushes sealed project state to a private git remote you control, with no EGC server involved.

After egc install, EGC detects installed AI coding tools and registers local MCP servers in each, so tools read and write a shared memory through natural language in any language: "save this session", "what did we decide about auth?". The Memory module stores decisions, session context, working memory and learned lessons per project/branch in ~/.egc (AES-256-GCM encrypted). Session Mesh runs a live bus where open sessions announce work, claim files, hand off tasks, and wake on events via session_wait; tools with a turn hook (Claude Code, Antigravity, Codex, Trae, Amp, Kiro, OpenCode 2) get notices at their next turn, while Cursor/Copilot read the bus through session tools. Guardian validates commands, gates risky writes and prevents context overflow in the background; orchestrate_task also returns relevant code found via a local graph of your project. Token Crusher compresses git logs, test spam, install noise and giant JSON by up to 90% before shell output reaches the model, keeping every error and warning, and answers "how much did I save?" from a local ledger. Team Brain syncs sealed state via egc team init --backend git --remote <url> and egc team sync to a private git remote you own.

  1. Developers using both Cursor and Claude Code: a decision made in a Cursor tab is already known when you switch to a Claude Code terminal, with no re-explaining
  2. Engineers running parallel sessions: two Cursor tabs plus a Codex session claim their files through Session Mesh instead of colliding
  3. Users worried about token burn: git logs, test spam and giant JSON are compressed up to 90% by Token Crusher before reaching the model
  4. Developers on multiple machines: Team Brain syncs memory to your own private git remote to keep project state consistent
  5. Security-conscious users: Guardian validates commands and gates risky writes in the background, with nothing to invoke
  6. Anyone evaluating real savings: ask "how much did I save?" in any language and get the answer from the local ledger

Key setup facts

Pulled from the install and usage notes below. The project README has the current values.

Install / run
  • npm install -g @egchq/egc && egc install

How do you install or deploy this agent?

Requires npm. Install globally and enable across supported tools:

npm install -g @egchq/egc && egc install

egc install detects your tools, registers two local MCP servers in each, writes the memory protocol, and sets up the Token Crusher. It asks one question — whether you also want the optional Prompt Library (default: no).

Optional: cross-machine memory sync (Team Brain):

egc team init --backend git --remote https://github.com/you/egc-memory.git
egc team init --backend git --remote https://github.com/you/egc-memory.git --key <team key>
egc team sync

Note: the --key shows in the process list and stays in shell history — clear that line and avoid shared machines.

How do you use this agent?

There is no step two. Open any supported AI tool and just talk, in any language: "hi", "let's continue", "remember this decision", "what did we decide about auth?" — EGC understands the intent and stores or recalls context automatically. Sessions connect, memory loads, and every open tab knows what the others are doing. A live dashboard with agent activity, tokens and costs starts right after installation. Team Brain sessions autosync from init (egc team autosync off disables it). Explicit commands are documented, but you will probably never need to type one.

What are this agent's strengths and limitations?

Pros
  • One install covers 29 AI coding tools with shared memory and context, no per-tool configuration
  • Fully local memory: AES-256-GCM encrypted in ~/.egc, scoped per project/branch, never committed to your project's git
  • Token Crusher cuts noisy shell output by up to 90% while keeping every error and warning, directly lowering model costs
  • Natural-language interaction with no commands to memorize; Team Brain syncs via your own git remote with no EGC server in the path
Limitations
  • Guardian and turn-hook context injection depend on each tool's own hook support; some tools (e.g. Auggie) expose no hook surface and get no safety layer
  • Cross-machine sync requires you to provision and maintain a private git remote, and a remote used with an earlier version may still hold the memory database in its history
  • The team key passed via --key appears in the process list and shell history, requiring manual cleanup and care on shared machines
  • The value depends on using the supported tool ecosystem; if your main tool is not among the 29 supported, benefits are limited

How does this agent compare with similar options?

The README names no specific competitor, but its positioning (a cross-tool shared agent-memory layer built on MCP, serving Cursor, Claude Code, Copilot, Aider and others) contrasts with each AI coding tool's own built-in, single-tool memory: EGC's differentiator is one local engine serving all tools at once rather than per-tool context silos.

Key facts side by side with the most closely related agents.

Agent Source review Form / cost Stars Updated Language Full support on
EGC — One Brain for Every AI Coding Agent This agent 76 · Good CLIFree ★ 70 today JavaScript Codex · Claude Code
LeanCTX Context Intelligence 69 · Some gaps CLIFree + model costs ★ 4k 5d ago Rust Codex · Claude Code · OpenAI API · Claude API
Emulo 76 · Good Agent plugin / skillFree + model costs ★ 306 1mo ago HTML Codex · Claude Code
Mnemo Cortex 75 · Good Self-hosted serviceFree ★ 161 2d ago Python Codex · Claude Code · Claude.ai

How does FollowAgents rate this agent?

FollowAgents source review · FARS-2.1
Good
76/ 100 5-point scale 3.8 / 5
Trust 21/29
Reliability 11/14
Adaptability 15/18
Convention 15/18
Effectiveness 9/13
Verifiability 5/8
Why each dimension lost points
Trust21 / 29 · 3.6/5

Evidence shows local-first, no network services, credential-file-level write blocks, AES-256-GCM at-rest encryption with HMAC integrity, git clean filter against leaks, pinned/audited dependencies, and a fail-open-to-fail-closed hook fix — sensitive_data_handling earns 3. Deductions: HMAC check documented as fail-open, the Guardian protocol mandates automatic agent calls without a user-confirmation step, validate_content is regex-only and advisory, install writes into many tools' config files, and CI fuzzing actions are pinned to a third-party fork (Maqbool61/clusterfuzzlite) rather than upstream — least_privilege, user_confirmation, dependency_security get 2. Uninstall is install-state-driven with dry-run, but ~/.egc state and protocol blocks are kept on purpose, so rollback gets 2. Named author with consistent links, but unverified publisher and self-claimed OpenSSF badges — source_attribution 2.

Reliability11 / 14 · 3.9/5

Docs are largely consistent (version 1.1.25 across package.json/plugin.json; three-stage install coherent); deductions: AGENTS.md says '230+ skills' vs 232 elsewhere, and AGENTS.md install commands (sh install.sh) diverge from the npm path — self_consistency 2. Node engines, optional uv, and retired-tool id handling are clearly documented — dependency_availability 2. TROUBLESHOOTING and egc doctor classify errors, exit codes, and fixes thoroughly — failure_messages 3.

Adaptability15 / 18 · 4.2/5

Multi-tool, multilingual audience with clear bare/project/full scenarios — audience_and_scenarios 3. Integration tiers and known limitations document per-tool hook coverage honestly (Roo Code partial, Auggie none) — capability_boundaries 3. Deductions: Auto-Intuition relies on intent inference with only documented (not demonstrated) trigger precision, and the 29-tool support surface cannot be fully checked in the packet — trigger_precision and environment_fit 2.

Convention15 / 18 · 4.2/5

Full directory/manifest/schema architecture docs — information_architecture 3; thorough install docs covering npm, source, targets, permissions — install_notes 3; candid known-limitations sections — known_limitations 3; Apache-2.0 full text consistent everywhere — license 3. Deductions: no CHANGELOG file in the packet (history only via issue references), the single-npm-package claim is not statically checkable, examples skew to troubleshooting with no FAQ — naming_stability, versioning_changelog, examples_and_faq 2; single-developer maintenance with a roadmap but bus-factor and update-path risk — maintenance_responsibility 2.

Effectiveness9 / 13 · 3.5/5

Structured reports, doctor JSON, and a token-savings ledger aid usability, but effectiveness cannot be statically proven — output_usability 2. Deductions: headline numbers (90% token savings, 29 tools, 61/232/77 counts) are self-asserted and unverifiable in the packet, and the cost side (global package, multi-target config writes, hook chains) is nontrivial — marginal_value and cost_benefit 2.

Verifiability5 / 8 · 3.1/5

The security assessment cites issue numbers and versions per finding — claim_traceability 2; README/docs/package.json corroborate — cross_source_corroboration 2. Deductions: the assessment self-describes as a mitigation-tracking update, not an independent audit; performance and coverage claims blend fact with aspiration — fact_inference_separation 2.

Risks and how to mitigate them
  • Static review, no execution: encryption, hook interception, and token-savings behaviors are not independently verified.
  • Install writes into multiple AI tools' config files and registers MCP servers; ~/.egc state and the protocol block are intentionally kept on uninstall and need manual cleanup.
  • The Guardian protocol mandates automatic pre-command validation with 'no exceptions' — effectively continuous autonomous security decisions by the agent; understand its failure semantics before use (HMAC check is fail-open by design, validate_content is advisory-only).
  • CI fuzzing actions are pinned to a third-party fork rather than official clusterfuzzlite, adding a supply-chain surface; the Team Brain key appears in shell history and the process list.
  • Headline claims (90% token savings, 29 tools, 61/232/77 component counts) are self-asserted and unverified.
  • Single maintainer with bus factor 1; publisher is not verified by the curated registry.
Evidence confidence: Low Reviewed Nov 21, 2026 Reviewed revision 927fb12206a2
See the full review method →
Maintain this project? Add the FARS badge to your README

The badge shows the current review score and verdict and links back to this page. It refreshes about once an hour after a re-review.

FARS

[![FARS review](https://followagents.com/badge/egc.svg)](https://followagents.com/en/agents/egc)
<a href="https://followagents.com/en/agents/egc"><img src="https://followagents.com/badge/egc.svg" alt="FARS review"></a>

FAQ

Is EGC free, and will it ever be paid?
The engine is Apache-2.0 and stays free. If EGC ever offers something paid, it will be a team layer on top of the engine — never the memory on your machine.
Does my code or data leave my machine?
No. Memory lives in ~/.egc, AES-256-GCM encrypted and never committed to your project's git. Only if you enable Team Brain does sealed state sync to your own private git remote, with no EGC server involved.
Do all 29 tools get the full feature set?
No. Guardian and turn-hook context injection depend on each tool's hook support; the integration tiers doc (docs/spec/integration-tiers.md) states exactly which tools get what. A few, like Auggie, expose no hook surface yet.
Do I need to learn new commands?
Essentially no. Everyday operations are natural language in any language — "save this session", "remember this decision". Commands exist and are documented, but the author expects you will rarely type one.
Is the Prompt Library required?
No. It is an optional library separate from the engine (61 agents, 232 skills, 77 commands, 109 rules) and off by default. Skip it and the engine works exactly the same.
Is EGC — One Brain for Every AI Coding Agent open source?
Yes. The source code is on GitHub (Fmarzochi/EGC) under the Apache-2.0 licence.
Is EGC — One Brain for Every AI Coding Agent safe to use?
FollowAgents' FARS review (Nov 21, 2026) scored EGC — One Brain for Every AI Coding Agent 21/29 on trust and safety. None of the eight safety controls the review checks for was missing outright.
Is EGC — One Brain for Every AI Coding Agent still maintained?
Yes. The latest commit on GitHub is from 2026-11-21, within the last 30 days.
Who makes EGC — One Brain for Every AI Coding Agent?
EGC — One Brain for Every AI Coding Agent is published on GitHub by the account Fmarzochi. FollowAgents has not verified which person or company is behind that account.
What is EGC — One Brain for Every AI Coding Agent's official website?
The project's GitHub repository lists https://fmarzochi.github.io/EGCSite/ as its website. That link is set by the repository owner; the source code itself is on GitHub (Fmarzochi/EGC).
Was this page helpful?
View on GitHub ↗ Install ↓

Compare agents like this one

The same FARS review applied across the shortlist this agent qualifies for.

Related concepts