u/_monospace_

I built a small thing for my own coding workflow and wanted to share it here because I’m curious if other people run into the same issue.

Repo: https://github.com/MihirShrivastav/APAM

The problem I kept running into with coding agents was not really code generation itself but continuity across multiple sessions.

They can be pretty effective inside a session, but once a codebase gets dense, a lot of useful context gets lost between sessions. And if you use more than one agent, the handoff is usually even worse. You end up re-explaining the repo, re-investigating old bugs, or losing track of why some decision was made 2 days ago, all the while wasting precious rate limit in this process.

I have been working on something called APAM - Anthropomorphic Procedural Agent Memory for an enterprise project in the energy sector.  In that project, we were building a plant operational intelligence system, and a big part of the work was designing a more human-like memory architecture for long-running agent behavior. That system used a 7-layer memory model.

APAM is basically a simplified abstraction of that idea, adapted for coding agents. Not the full architecture, just the part that felt most useful and practical for day-to-day software work.

What it does in simple terms is keep project memory in layers:

• important facts / constraints / decisions
• session episodes
• longer-lived project intelligence like architecture, patterns, and module knowledge

The part that has been most useful for me is using it across both Claude Code and Codex. They can both write to and read from the same memory store, so switching between them is a lot less awkward than it usually is.

A few concrete ways it has helped me:

• providing coding agents with instant access to key information about the project
• helping keep track of more intricate details such as architecture, design choices etc.
• remembering why a certain implementation choice was made
• keeping track of bugs that were already fixed or investigated
• making future sessions less dependent on scrolling through old chats
• helping with dense repos where context rebuild takes time
• making Claude Code / Codex handoff much cleaner

Codex has actually been pretty decent at writing back useful notes about bugs fixed, files touched, and decisions made. That part has made later sessions easier because there’s at least some usable trail of what happened.

If anyone wants to try it, setup is pretty straightforward.

Install:

• clone the repo
• go into packages/apam-mcp
• run npm install
• run npm run build
• run npm link

That gives you the APAM CLI and MCP commands globally.

Then from the repo you actually want to track:

• run apam init

If you want to use it with Claude Code:

• run apam integrate claude

If you want to use it with Codex:

• run apam integrate codex

After that, the basic idea is:

• APAM creates a local memory store for the repo
• the agent can read project memory at session start
• during or after work, it can write back decisions, session episodes, fixes, patterns, and other useful context
• if you use both Claude Code and Codex, they can both work against the same memory for that repo

So over time it builds a usable trail of what happened in the codebase instead of leaving all of that buried in old chats.

If you try it and run into problems, feel free to open an issue on GitHub or DM me.

If anyone here tries it, I’d be interested in honest feedback:

• what feels useful vs not useful
• what feels missing
• what you would want agents to remember
• what would make cross-agent handoff better
• what parts of this feel annoying, risky, or too manual