Every agent session starts from zero

We spent the last few months deliberating and then building software that runs on top of AI coding agents. The question that kept intriguing us:

Why does every agent session start from zero?

When a team works on a long-running project, the context is not just in anyone's head. It has seeped into the codebase, the PR reviews, the decisions recorded in comments and commit messages. After a few weeks or months, a new person inducted into the project reads, absorbs and continues building based on what's there.

For an agent, every session starts cold. The model only sees your prompt and the files in front of it. The model is unaware of the past decisions you made, the constraints you discovered and the reasons why you did things in a certain way. Unless you type it again!

So we become the memory. The sole entity holding the thread.

This is a risk nobody accounted for. As the agent generates code, you try to absorb it. The context keeps on growing while your memory remains constrained.

We have experienced this and watched teams go through it too:

• Senior engineers spending time every day to reiterate a project's constraints.

• Relying on one person who has been there from the start and knows the whole architecture.

• The "quick resume" that turns into an endless rabbit hole because the summary has messed up.

You write a summary on Tuesday, it veers a bit by Thursday, and by Monday it misleads. So you stop trusting it and start reworking everything from scratch. It is not a tool problem but a process issue.

Why a better model isn't the fix

A better model doesn't remember the previous session. A bigger context window doesn't help either. It just lets you stuff more reminders. The fix is to make the process hold the context.

We have been experimenting with a simple approach. Even before the agent writes a single line of code, it has to write down its approach and assumptions. That is reviewed. Then the agent works one task at a time, one commit per task, and at each step it records what it did and why. The session can end anywhere. The thread is on a disk, not in someone's memory.

The effect was that we shifted the importance from holding things in memory to reviewing things properly. The agent keeps working, the context keeps accumulating, and you judge the work instead of reconstructing it.

You can't call this a productivity hack. It is moving from babysitting an agent to a reliable process on a long-running project.

The question we are seeking answers to

We are building this as an open-source harness that wraps any agent with these gates, so that you're not locked into any one tool. We want answers from people who have lived this:

Have you lost threads across agent sessions on long projects, or is that not an issue for how you work?

We are better off hearing that "this is a non-issue for us, and here's why" than "this looks cool". We are eager to hear what happens on your project when a session ends and a new one starts. That's what we want to know.

FAQ

What does "every agent session starts from zero" mean?

Every new session begins with no memory of earlier decisions. The model only sees your prompt and the files in front of it.

Why doesn't a better model fix this?

Remembering past decisions isn't a capability problem, it's a persistence problem. A bigger context window just lets you re-supply more context.

How do you keep context across agent sessions?

Write the approach and assumptions down before any code, work one task per commit, and record what changed and why. The thread lives in the repo, not in someone's memory.

Is this a tooling problem or a process problem?

A process problem. The context has to live somewhere durable, not in a chat that ends.

Repo: https://github.com/oystro/oystro-oss