u/geanatz

Every new coding-agent session usually starts with the same problem:

The agent has no idea what happened before.

It does not know the project decisions, previous attempts, constraints, unresolved tasks, implementation details, or the small context that makes the next step obvious.

So you end up explaining the same things again:

what the project does

what was already built

what should not be changed

what decisions were made

what errors already happened

what still needs to be done

Handoff notes help, but they are manual.

They get outdated, incomplete, or too long. And if you work on multiple projects, keeping every agent properly oriented becomes annoying fast.

What Curion does

Curion is an open-source MCP that gives AI coding agents persistent project memory across sessions.

The goal is simple:

A new session should not start blind.

The agent should be able to recover the important project context and continue working without needing the user to repeat everything manually.

Curion is project-first by default. It stores memories tied to the current project, such as:

decisions

constraints

useful notes

implementation history

unresolved tasks

But Curion is not just a raw save/search database.

The main idea

Curion uses a dedicated memory agent.

The main coding agent works on the task.

The Curion agent manages memory.

It can:

remember useful context

organize project knowledge

update older information when needed

detect conflicts

recall only what is relevant for the current task

The idea is to avoid two common problems:

agents forgetting everything between sessions

agents receiving a huge dump of raw memories and wasting context figuring out what matters

With Curion, the main agent can ask for memory and get back a clear, useful context summary instead of starting from zero.

GitHub: https://github.com/geanatz/curion

How are you currently handling memory between coding-agent sessions?

Are you using handoff files, CLAUDE.md / AGENTS.md, manual notes, MCP tools, or something else?

I’ve been working on Curion, a memory system for AI agents built around a simple idea:

The main agent should not have to manage memory manually.

Most AI agents are useful inside a single session, but they still lose important context between sessions. Project decisions, implementation history, constraints, unresolved tasks, and previous reasoning often disappear unless I manually write long handoff notes.

At first, the obvious solution seems to be giving the agent memory tools: save, search, update, delete, edit.

But that creates a second problem.

If the main agent has to manage memory by itself, it can easily receive too many raw memories. Some are relevant, some are stale, some are only partially related, and some may conflict with newer information. The agent then has to spend context and attention deciding what matters.

That creates context bloat.

Curion takes a different approach.

I think of Curion as a librarian for AI agents.

A good librarian does not just throw every possibly related book at you. They understand the question, know how information is organized, filter what matters, notice conflicts, ask clarifying questions when needed, and return the most useful context.

That is what Curion is meant to do for agent memory.

The main agent only needs to say:

“I want to remember this.”

or

“I need to recall something about this.”

Curion handles the rest.

When saving memory, Curion can decide how information should be stored, whether it relates to existing records, whether something should be updated, and whether a conflict requires clarification.

When recalling memory, Curion does not just dump raw search results into the agent’s context. It retrieves relevant records, evaluates what is useful for the current task, synthesizes the context, and clearly says when nothing relevant was found.

The analogy I use is human memory. When we want to remember something, we do not consciously search through billions of memories. We ask for what we need, and the relevant memory appears automatically beneath the surface.

Curion is built around that same interface idea for AI agents.

It is project-first: Curion focuses on the project the agent is currently working in. It can also use cross-project recall when information from another project is actually relevant.

Curion is not just a save/search tool. It is a collaborative memory layer: a specialized memory librarian that helps agents remember responsibly, reduces context bloat, and gives the main agent only the context it actually needs.

GitHub: https://github.com/geanatz/curion

NPM: https://www.npmjs.com/package/@geanatz/curion

Portfolio: https://geanatz.com