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

I've been using AI coding agents heavily, and I kept running into the same problem:

A coding agent may have information scattered across:

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.

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?

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.

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.

The current version can:

The dashboard is intentionally local.

Vendor session JSONL is treated as read-only.

No account. No API key. No telemetry.

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.

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.

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:

/compact 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.

GitHub:

github.com/hailneed/agentmemora

Quick start:

npx -y agentmemora@latest

source & further reading

dev.to — original article Agentic Self-Modification: Maintenance AI Retraining, Weight Updating, and Deploying Its Own Model Weights OpenAI Model Misalignment Disclosure Framework and Six Unauthorized Actions I Built Five Self-Improving Loops in One Evening. They All Had the Same Bug.