DEV Community: Felipe Marzochi

I got tired of re-explaining my project to AI every session, so I built EGC

Felipe Marzochi — Mon, 22 Jun 2026 21:00:58 +0000

You open your AI coding tool on a project you haven't touched in a week. You type "let's continue." And then it begins.

"Can you remind me what we're working on?"

You explain the stack. Again. The decisions you made. Again. What failed last time. Again. By the time you've re-established context, you've burned 15 minutes and half your focus.

I got tired of this. So I built EGC.

What EGC does

EGC is a local runtime that gives every AI coding tool you use a persistent memory across sessions. At the end of each session, your AI saves what it learned: decisions made, what failed, your preferences, what to pick up next. At the start of the next session, it loads that state back — on its own, without you asking.

This is what it looks like in practice:

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

=== EGC Stack Briefing ===
Stack: typescript, javascript
Stack agents: typescript-reviewer, javascript-reviewer
Always use: code-reviewer
===

You didn't type anything. You just started working.

How it works

EGC ships two MCP servers that run locally alongside your AI tool.

egc-memory handles persistence. It exposes 14 tools your AI calls automatically during the session:

get_state — loads your project memory at session start
update_state — saves decisions, preferences, and next steps
store_decision — persists individual decisions to SQLite
search_history — full-text search with BM25 ranking across all past sessions
lesson_save / lesson_recall — cross-session knowledge with confidence decay
detect_patterns — surfaces recurring commands and errors from hook events
working_memory_set/get — transient context with TTL

State files live at ~/.egc/state/<project-slug>.md. One file per project, plain Markdown, human-readable. No cloud. No subscription. No black box.

egc-guardian handles safety and context compression:

validate_command — checks shell commands against project rules before execution
validate_write — validates file write paths
reduce_context — compresses file payloads to save your token budget
auto_learn — mines session failures and writes actionable lessons to all AI tool config files

One install, every tool

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

That's it. EGC detects which AI tools you use and configures itself automatically. It works with:

Claude Code
Cursor
Gemini CLI
Windsurf
Kiro
Any MCP-compatible tool

And it works with any model: Claude, GPT-4o, Gemini, DeepSeek, Qwen3, Llama 4 via OpenRouter.

The sync daemon

egc watch keeps all your tool configs in sync bidirectionally. Edit context in Cursor and it propagates to Gemini CLI, Copilot, and Windsurf automatically. Edit it in any tool and it syncs back to ~/.egc/state/.

egc watch        # watch current project
egc watch --quiet

Why local-first matters

Every session state is a plain Markdown file on your machine. You can read it, edit it, version-control it, and delete it. There's no account, no API key to EGC, no server that can go down and take your memory with it.

The MCP servers run as local Node.js processes. Nothing leaves your machine unless your AI provider does it (which it would do regardless).

Bonus: 479 prompt components

EGC ships with a library of 63 agents, 229 skills, 76 commands, and 111 rules written from real engineering sessions. Install them or ignore them entirely — EGC gives you persistent memory either way.

Open source, one developer

EGC is MIT licensed and built by one person. The GitHub repo is at github.com/Fmarzochi/EGC.

If EGC changed how you work, a star helps other developers find it.

If you hit an issue or have a question, open an issue or join the Discord.

EGC: Your AI agents never start from zero again

Felipe Marzochi — Sat, 20 Jun 2026 21:55:37 +0000

Every time you open a new session with an AI coding tool, it starts from zero. It does not know what you decided yesterday, what failed last week, or what comes next. You have to explain the project again. And again.

EGC (Extended Global Context) fixes this.

EGC is a local runtime that gives every AI coding tool you use a persistent memory. At the end of each session, the AI saves what it learned: decisions made, what failed, your preferences, what comes next. At the start of the next session, it loads that state back automatically.

One install. Every tool. Every session.

Website: https://fmarzochi.github.io/EGCSite

What it looks like in practice

You open Claude Code on a project you have not touched in two weeks. Without typing anything:

State loaded from egc-memory via ~/.egc/state/Projects--MyApp.md
Context and preferences acknowledged.
Ready to pick up:
  - Test full install on a clean machine
  - Add GEMINI.md with session memory protocol
  - Publish v1.0.1 fix after clean install test passes

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

How it works

EGC ships two MCP servers that run locally during every session.

egc-memory: 14 tools for persistent memory

Tool	What it does
`get_state`	Loads project memory at session start
`update_state`	Saves decisions, preferences, and next steps
`store_decision`	Persists a single decision to SQLite
`query_history`	Returns past decisions by timestamp
`search_history`	Full-text search with BM25 ranking
`working_memory_set`	Stores transient context with a TTL
`lesson_save`	Records cross-session knowledge with confidence decay
`lesson_recall`	Retrieves active lessons above a threshold
`detect_patterns`	Surfaces repeated commands and recurring errors
`compress_observations`	Compresses hook events to save token budget

State files live at ~/.egc/state/<project-slug>.md. One file per project. Plain Markdown. Human-readable.

egc-guardian: 5 tools for context and safety

Tool	What it does
`validate_command`	Checks shell commands before execution
`validate_write`	Validates file paths to prevent unsafe writes
`reduce_context`	Compresses file payloads to save token budget
`orchestrate_task`	Routes prompts with agent/skill context
`auto_learn`	Mines session failures and writes lessons to CLAUDE.md

Every tool. One memory.

EGC installs into whichever tools you already use:

Claude Code
Cursor
Gemini CLI / Antigravity
Windsurf
GitHub Copilot
Trae
Zed
Aider
OpenCode
Kiro
Amp

All of them read from and write to the same ~/.egc/state/ directory. What Claude knows, Gemini knows. No copy-paste, no re-explanation.

Install

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

Or without installing globally:

npx @egchq/egc install

EGC detects which tools you have installed and sets them up automatically.

Prompt library included

EGC ships 479 components as a bonus: 63 agents, 229 skills, and 76 commands written from real engineering sessions. Skip them entirely and EGC still gives you persistent memory. Or use them to extend any AI tool you already have.

npx skills add Fmarzochi/EGC

Open source

EGC is MIT licensed, built by one developer, maintained in the open.

Website: https://fmarzochi.github.io/EGCSite
GitHub: https://github.com/Fmarzochi/EGC
npm: @egchq/egc
Discord: https://discord.gg/AtazrtxJ

If EGC changed how you work, a star goes a long way.

I built persistent memory for AI coding tools one install, every tool, no more re-explaining context

Felipe Marzochi — Thu, 11 Jun 2026 20:37:13 +0000

Every AI coding session starts from zero.

Close Claude Code and open it tomorrow. The AI doesn't know your project. You spend the first 10 minutes re-explaining the stack, the architectural decisions from last week, the approach that failed after three attempts.

It gets worse when you switch tools. Move from Cursor to Codex and you start over again.

I got tired of this. So I built EGC — Extended Global Context.

What EGC does

One install. Every tool. Permanent memory.

sh install.sh detects which AI tools you have (Claude Code, Cursor, Codex, Gemini CLI, OpenCode, Windsurf, Kiro, Trae, CodeBuddy) and registers two local MCP servers in all of them. It also writes the memory protocol into each tool's global instruction file, so the AI calls get_state({}) at session start and update_state({}) at session end — automatically.

The state file lives at ~/.egc/state/ on your machine. It follows the project, not the IDE.

How it looks in practice

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

State loaded from egc-memory

Context acknowledged.

Ready to pick up:
• Fix the auth middleware regression
• Add rate limiting before deploy
• Decision: use Redis, not in-memory (discussed 2 sessions ago)

The AI already knows. You just start working.

Token savings

Rebuilding context from scratch costs ~1,500 tokens per session. EGC delivers the same in ~200 tokens.

20 sessions/month = ~$0.08 saved. The money is small. The interrupted flow is not.

Installation

Requires Node.js 20+.


bash
npm install -g @egchq/egc
egc install

That's it. Run egc doctor to verify.

The two MCP servers

egc-memory — the one you use every session
- get_state — reads project memory at session start
- update_state — saves decisions, preferences, next steps
- store_decision — persists a decision to SQLite
- query_history — returns past decisions by timestamp

egc-guardian — runs in the background
- validate_command — blocks shell injection
- validate_write — blocks writes to sensitive paths
- reduce_context — deduplicates Markdown payloads

It's open source

GitHub: https://github.com/Fmarzochi/EGC

MIT license. Built by one developer. 13 supported tools. If it saves you time, a star helps other developers find it.

---
If you've been re-explaining context every session, try it and let me know what breaks.
![ ](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/7y8tf9v3gtaqdwln2wye.png)

I solved the problem no AI company could: persistent memory across every coding assistant

Felipe Marzochi — Sat, 06 Jun 2026 15:13:14 +0000

The silent tax every developer pays

Every session starts from zero. The AI does not know what you decided last week. It does not know what failed. It does not know your stack preferences or the architectural direction you chose three sessions ago.

Rebuilding that context costs time and tokens -- around 1,500 tokens per session. Multiply by 20 sessions a month and you have lost over 3 hours just re-explaining yourself.

No company has solved this. Not Anthropic, not OpenAI, not Google. The AI always resets.

I got tired of it and built EGC -- Extended Global Context.

The solution: two local MCP servers

egc-memory

Persistent state across sessions. At the start of every session, the AI calls get_state({}). It reads a plain Markdown file from ~/.egc/state/ and knows exactly where you left off.

At the end, it calls update_state({...}) with decisions made, what to avoid, and what to pick up next.

egc-guardian

Command validation before execution. Blocks shell injection, blocks writes to sensitive paths, enforces trust levels. Runs silently in the background.

One install, every tool

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

Detects Claude Code, Cursor, Codex, Gemini CLI, Kiro, OpenCode, Trae, CodeBuddy and registers both MCP servers in all of them.

Token savings

~200 tokens per session vs ~1,500 rebuilding from scratch. No cloud. No subscription. Free and open-source.

Try it

GitHub: https://github.com/Fmarzochi/EGC
Site: https://fmarzochi.github.io/EGCSite/
npm: @fmarzochi/egcWould love feedback from anyone using multiple AI tools.