Eggshell
Local memory for AI agents to reuse work, spend fewer tokens
Start new thread

Eggshell - Local memory for AI agents to reuse work, spend fewer tokens

by
•
Eggshell carries useful work across AI agent chats. It stores results and evidence locally, retrieves relevant memory, and helps reduce repeated investigation—without LLM calls to organize that memory.

Add a comment

Replies

Best
Maker
📌

Hi Product Hunt! I'm Momo, the maker of Eggshell.

When you open a new AI coding chat, useful work from the previous conversation can get left behind. The agent may search the same files, trace the same code, and spend tokens rebuilding context.

I built Eggshell with GPT-6 Astra to help carry that work forward. It saves tool results, findings, and their evidence in a local .egg graph, then brings relevant work into a later chat. It does not call an LLM to summarize or organize the memory.

Eggshell is open source and written in Lean. You can try it through the Codex plugin and inspect the memory that actually reached the next chat. Separate experimental adapters are also available for Claude Code, Gemini CLI, Cursor, and OpenCode.

In our published LLVM follow-up experiment, it used about 82% fewer input-plus-output tokens than a saved fresh-chat reference. Nine of the ten answers needed no substantive correction in our review. This measured one task with existing prior work using Luna; it is not an Astra benchmark or a general savings guarantee. The full measurements and review limits are in the README.

I'd love feedback from people who return to related work across coding sessions. Try the two-chat example and tell me what carried over, what still had to be checked, and where setup was difficult.

Source, installation, and evidence:

OpenAI
GPT-6 Astra Challenge
What real task does your product handle with GPT-6 Astra?
Maker
Astra made it much easier to develop Eggshell's distinctive memory structure and formally verify key properties in Lean. Eggshell connects work, results, and evidence in a graph. It links equivalent pieces of work across chats and follows those relationships to uncover reusable results, while keeping unfinished work explicit. This lets a new chat build on prior investigation without LLM calls to organize memory. Astra helped me turn this design into running code and prove properties such as preserving provenance and ensuring selected results come from the recorded graph. Experiments with real agent sessions then demonstrated work reuse and token savings, with answer quality reviewed. Astra expanded what I could pursue: bringing a theoretical memory design through implementation, machine-checked proofs, and experimental validation.
How does it compare with GBrain, Mnemosyne and other memory layers for AI agents?
Maker

 

Great question! There’s overlap: GBrain is a broader knowledge layer, and Mnemosyne provides general-purpose persistent memory for agents. Eggshell has a more specific focus: reusing work across independent coding-agent chats to reduce repeated work and token use.

It automatically records repository searches, tool results, and conclusions, then passes relevant prior work into a new chat. For example, an investigation into how configuration is loaded can help a separate chat identify which tests need updating, instead of rediscovering everything. Changed or unresolved facts still need checking.

Storage, matching, and graph processing run locally, with no LLM calls to summarize or organize memory. You can inspect exactly what context was handed to the agent and why it was selected. That context still consumes normal model input tokens.

Local memory isn’t unique to Eggshell; the emphasis is this automatic, inspectable work-reuse workflow. Our reported ~80% token reduction comes from one LLVM follow-up workload with existing prior work, compared with starting fresh—not a head-to-head benchmark against GBrain or Mnemosyne.

The use case I’m building for is: same project, new chat, less repeated investigation.