Your coding agent remembers more than MEMORY.md — so I built a local inspector for it

hailneed — Fri, 18 Sep 2026 14:41:37 +0000

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

DEV Community: hailneed