I've been using AI coding agents heavily, and I kept running into the same problem:
Useful context doesn't live in one place
A coding agent may have information scattered across:
- the current conversation
- previous sessions
- subagent conversations
- auto-memory
- project instruction files
- decisions that were discussed but never persisted anywhere
As sessions get longer, starting a fresh session or compacting the current context starts to feel risky.
I found myself asking questions like:
What does the agent actually know about this project?
Which important decisions only exist inside an old session?
What was saved as durable memory?
What did a subagent discover that I might never see again?
What context should I preserve before starting over?
I wanted a way to inspect this before trying to build yet another memory system.
So I built AgentMemora.
Memory intelligence instead of another memory database
There are already good projects focused on giving agents persistent memory.
AgentMemora takes a different approach.
It doesn't try to replace the memory system used by your coding agent.
Instead, it acts as an inspection and context-control layer over the state that already exists locally.
The basic workflow is:
Discover
↓
Understand
↓
Curate
↓
Preserve
↓
Transfer
The question isn't only:
How can I give my agent more memory?
It's also:
What does my agent already know, where did that knowledge come from, and what is worth preserving?
Project-first context exploration
One thing I changed while building v0.2.0 was how sessions are presented.
A global list of hundreds of sessions quickly becomes difficult to navigate.
So AgentMemora now starts with projects.
For each project you can inspect:
Project
├── Primary Sessions
│ ├── Session A
│ ├── Session B
│ └── Session C
│
├── Subagent Transcripts
│ ├── Subagent A
│ ├── Subagent B
│ └── ...
│
├── Durable Memory
├── Project Instructions
└── Context-loss Signals
This makes it much easier to understand the context footprint of one codebase.
You can see how many primary sessions and subagent traces exist before drilling into individual conversations.
Subagents were especially interesting
Subagent conversations are easy to forget about.
An agent may delegate research, architecture analysis, or implementation work to another agent.
That subagent can discover something important.
But later, from the developer's perspective, that information can become difficult to find.
AgentMemora indexes those local traces and groups them under their project so they can be inspected alongside the primary sessions.
This was one of the reasons I wanted the project-first model instead of treating everything as one conversation history.
What AgentMemora currently does
The current version can:
- discover local Claude Code session history
- distinguish primary sessions from subagent transcripts
- group context by project
- inspect supported durable memory and instruction files
- surface possible session-only context
- show conservative memory conflict signals
- identify stale memory candidates
- generate Resume and Fork commands
- export a Context Capsule
- provide a local Memory Intelligence dashboard
The dashboard is intentionally local.
Vendor session JSONL is treated as read-only.
No account.
No API key.
No telemetry.
Context Capsules
This is the part I'm most interested in developing further.
Instead of copying an entire huge conversation into another agent session, I want to make context portable.
AgentMemora currently supports exporting a basic Context Capsule from a session.
The longer-term idea looks like this:
Long Session
│
▼
Context Surgery
│
├── Architecture decisions
├── User constraints
├── Important files
├── Failed approaches
├── Open tasks
└── Relevant memories
│
▼
Context Capsule
│
├── New session
├── Another machine
└── Another coding agent
Rather than transferring everything, you should eventually be able to select only the context worth carrying forward.
I'm calling that idea Context Surgery.
It's not fully implemented yet, but it's one of the next areas I want to explore.
Running it
AgentMemora is available through npm.
npx -y agentmemora@latest
Or inspect the environment first:
npx -y agentmemora@latest doctor
It currently focuses primarily on local coding-agent context inspection, with Claude Code being the most complete session-history integration.
Why I'm open-sourcing it early
This is still an early project.
Before adding a lot more features, I want to understand how developers actually lose context when working with coding agents.
I'm especially interested in developers who:
- keep long-running coding sessions
- use multiple subagents
- frequently start fresh sessions
- use
/compact - work on several projects simultaneously
- switch between coding agents or machines
The next features shouldn't be based only on what I think is useful.
They should come from real context-loss cases.
So if you try AgentMemora, I'd especially like to know:
What useful information do you most often wish your coding agent had remembered when you start a new session?
And:
Would you rather preserve an entire session, or extract only the important decisions and constraints from it?
AgentMemora is open source and MIT licensed.
If this problem sounds familiar, feedback, issues, and contributions are welcome.
Try AgentMemora
GitHub:
github.com/hailneed/agentmemora
Quick start:
npx -y agentmemora@latest
Top comments (1)
What evidence makes a decision count as session-only after the same topic appears in a later transcript?