Egc Extended Global Context

@Fmarzochi

8 days ago

# memory context productivity cli ai-coding

Persistent memory and shared context for AI coding tools. Two local MCP servers give every AI coding tool a shared, permanent memory of your project across sessions and tools.

Overview Tools Comments

Overview

EGC - Extended Global Context

Your AI remembers your project across sessions and tools.

This is what EGC looks like in practice

You open Claude Code on a project you haven't touched in two weeks. Without typing anything:

State loaded from egc-memory via ~/.egc/state/Projects--MyApp.md

Context and preferences acknowledged (terse responses).

Ready to pick up the next items:
• Test full install on a clean machine
• Add GEMINI.md with session memory protocol
• Publish v1.0.1 fix to npm after clean install test passes
• Add mcp_server_count to audit.js

The AI already knows what you were building, what decisions you made, what failed, and exactly where you stopped. You didn't type anything. You just started working.

After sh install.sh, the memory protocol is injected into the global instruction files for Claude Code, Cursor, Codex, Gemini CLI, OpenCode, Windsurf, Amp, VS Code Copilot, Zed, Kiro, Trae, and CodeBuddy, so the AI reads state at the start of each session and saves it at the end. For tools where the AI instruction file isn't read automatically (varies by tool version), you may need to add the project's CLAUDE.md or equivalent to the session context manually.

The problem

Every AI coding session starts from zero. Close the window and the context is gone. Your stack preferences, the architectural decisions you made last week, the approach that failed after three attempts. Next session you spend the first ten minutes re-explaining ground you already covered.

It gets worse when you switch tools. Move from Cursor to Claude Code and you start over again. The AI doesn't know you. It never did.

How EGC fixes it

One install. Every tool. Permanent memory.

sh install.sh detects which AI tools you have installed (Claude Code, Cursor, Codex, Gemini CLI, OpenCode, Windsurf, Amp, VS Code Copilot, Zed, Kiro, Trae, CodeBuddy) and registers the MCP servers in all of them. It also runs a cognitive bootstrap that writes the memory protocol into the global instruction files for each tool, so the AI is instructed to call get_state({}) at the start of every session and update_state({...}) at the end.

For every supported tool:

Open any session → AI reads your project state → picks up where you left off
Close any session → AI saves decisions, preferences, next steps
Switch tools → same state file → same context → no re-explaining

The memory protocol requires the AI to call get_state and update_state via the egc-memory MCP tool. The bootstrap injects the instruction; the tool must support MCP to execute it.

The memory lives at ~/.egc/state/ on your machine, not inside any tool. It follows the project, not the IDE.

Token savings

Rebuilding context from scratch costs ~1,500 tokens per session. EGC's state file delivers the same information in ~200 tokens.

	Without EGC	With EGC
Context overhead per session	~1,500 tokens	~200 tokens
20 sessions/month	~$0.08–$0.09	~$0.011–$0.012
Time re-explaining context	10 min/session	0

The money saved is small. The time and interrupted flow are not.

Installation

Via npm (recommended)

npm install -g @egchq/egc
egc install

Linux / macOS

You need Node.js 18 or later. Not sure if you have it? Open a terminal and run node --version. If it shows 18 or higher, you're ready.

git clone https://github.com/Fmarzochi/EGC.git
cd EGC
sh install.sh

The installer runs these steps:

Compiles the MCP servers (egc-guardian, egc-memory)
Initializes the local SQLite database
Runs the cognitive bootstrap: writes the memory protocol into ~/.claude/CLAUDE.md (Claude Code) and ~/.gemini/GEMINI.md (AGY), creating the files if they don't exist, idempotent
Registers both MCP servers in every detected tool's config file
Asks interactively whether to install the prompt library (63 agents, 229 skills, 76 commands), skipped automatically in CI

The installer will print which tools it found and registered:

EGC install
  node v22.0.0
  building egc-guardian...
  building egc-memory...
  initializing database...
  bootstrapping cognitive protocol...
  ✓ ~/.claude/CLAUDE.md updated
  ✓ ~/.gemini/GEMINI.md updated
  registering MCP servers...
  ✓ registered in Antigravity CLI
  ✓ registered in Claude Code (global)
  ✓ registered in Cursor

Install prompt library? (63 agents, 229 skills, 76 commands) [y/N]:

Installation complete.
Run 'egc doctor' to verify.

Windows

git clone https://github.com/Fmarzochi/EGC.git
cd EGC
.\install.ps1

Prompt library

The prompt library is optional. During sh install.sh, you'll be asked whether to install it. In CI or non-interactive shells, this step is skipped. Install once to get access to 63 agents, 229 skills, and 76 commands written from real experience, not generated.

Type	Count	What it is
Agents	63 agents	Persona and behavior definitions
Skills	229 skills	Domain-specific workflow runbooks
Commands	76 commands	Command definitions and lifecycle hooks
Rules	111	Constraints and governance directives

Organized per harness under .cursor/, .claude/, .gemini/, .kiro/, and four others. Switch tools and the same workflows follow you.

Cross-harness distribution

Component	Total	Claude Code	Gemini CLI	Claude Code native
Agents	63	Shared (AGENTS.md)	Shared (AGENTS.md)	12
Commands	76	Shared	Instruction-based	31
Skills	229	Shared	10 (native format)	37

Supported tools

Tool	Skills	MCP registered	Cognitive bootstrap
Claude Code	`~/.claude/skills/<name>/`	Yes	Yes: protocol injected into `~/.claude/CLAUDE.md`
Antigravity CLI (AGY)	`.agents/skills/<name>/`	Yes	Yes: protocol injected into `~/.gemini/GEMINI.md`
Gemini CLI	`~/.gemini/`	Yes	Yes: protocol injected into `~/.gemini/GEMINI.md`
Cursor	`~/.cursor/`	Yes	Yes: protocol injected into global `cursor.rules` setting
Codex CLI	`~/.agents/skills/<name>/`	Yes	Yes: `persistent_instructions` appended to `~/.codex/config.toml`
OpenCode	`~/.config/opencode/skills/<name>/`	Yes	Yes: protocol written to `~/.opencode/instructions/EGC_MEMORY.md`
Windsurf	`~/.codeium/windsurf/skills/<name>/`	Yes	Yes: protocol injected into `~/.codeium/windsurf/`
Amp	`~/.amp/skills/<name>/`	Yes	Yes: protocol injected into `~/.amp/`
VS Code Copilot	`~/.github/skills/<name>/`	Yes	Yes: protocol injected into `~/.github/`
Zed	`~/.config/zed/skills/<name>/`	Yes (MCP via `context_servers` in `settings.json`)	Yes: protocol injected into `~/.config/zed/AGENTS.md`
CodeBuddy	`.codebuddy/skills/<name>/`	Context injection	Yes: protocol written to `~/.codebuddy/MEMORY.md`
Kiro	`~/.kiro/hooks/`	Yes	Yes: session hooks installed to `~/.kiro/hooks/`
Trae	`~/.trae/`	Context injection	Yes: protocol written to `~/.trae/MEMORY.md`
Obsidian	Yes, if already configured, synced to all tools	N/A	N/A

If you use Obsidian and have the Obsidian MCP server configured, the installer detects it automatically and gives every AI tool in your setup direct access to your vault: read notes, search, and write without any extra configuration.

MCP servers

EGC runs two local MCP servers over stdio.

egc-memory: the one you'll use every session

Tool	What it does
`get_state`	Reads project memory at session start
`update_state`	Saves this session's decisions, preferences, and next steps
`store_decision`	Persists a decision to SQLite
`query_history`	Returns past decisions by timestamp

egc-guardian: runs in the background

Tool	What it does
`validate_command`	Blocks shell injection and unsafe binaries
`validate_write`	Blocks writes to sensitive paths (`~/.ssh`, `/etc`)
`reduce_context`	Deduplicates and trims Markdown payloads
`orchestrate_task`	Routes prompts to relevant agents and skills

CLI

egc doctor         # verify both servers are built and working
egc status         # show the last 5 decisions in memory
egc install        # install prompt library to a target harness
egc catalog        # list available profiles and components
egc repair         # restore drifted or missing managed files
egc auto-update    # pull latest changes and reinstall managed targets

Architectural consolidation

Earlier versions of EGC explored distributed runtime concepts: FederationManager, ReplayEngine, cognitive orchestration layers, multi-provider dispatching. Those experiments were real explorations, not deception. They helped define what the project actually needed to be.

What the project actually needed was simpler and more useful: persistent memory across sessions, a validation layer, and a prompt library that works in every tool without reconfiguration.

The current runtime reflects that consolidation. Two MCP servers, local SQLite, plain Markdown state files, one install command. Everything else was removed or isolated.

The branch legacy-runtime preserves the full historical architecture for anyone who wants to study the evolution.

Community

Join the EGC Discord server to ask questions, share your setup, and follow development.

Join on Discord

#help — questions about EGC
#installation — setup issues
#show-and-tell — share your workflow
#feature-requests — propose ideas
#contributing — coordinate contributions

Support EGC

EGC solves a problem that no company has solved: AI memory that persists across sessions, across tools, and across CLIs.

Close Claude Code and open Cursor. The AI already knows your project. Switch to Codex. Same context. No re-explaining. No lost decisions. No starting from zero.

That's not a feature. It's a shift in how AI-assisted engineering works.

EGC is built by one developer, maintained in the open, and used by people who are done re-explaining context every session. If it saves you time, consider giving back:

Join the Discord (ask questions, share feedback, meet other users)
Sponsor on GitHub (for GitHub users, any amount)
Donate via PayPal (no GitHub account needed)
Star the repository (helps other developers find it)
Contribute (agents, skills, commands, bug fixes, docs via CONTRIBUTING.md)
Share (if EGC changed how you work, tell someone)

Every contribution, financial or otherwise, goes toward keeping this maintained, documented, and free.

Server Config

{
  "mcpServers": {
    "egc-memory": {
      "command": "npx",
      "args": [
        "-y",
        "--package",
        "@egchq/egc",
        "egc-memory"
      ]
    },
    "egc-guardian": {
      "command": "npx",
      "args": [
        "-y",
        "--package",
        "@egchq/egc",
        "egc-guardian"
      ]
    }
  }
}

Build with ShipAny.