AI Systems
The Missing Layer
A shared context layer that every AI agent can read from and update sounds like the solution. So why is every team still rebuilding context from scratch every day?
An engineer opens a new session and asks the agent to extend the search feature.
The agent proposes a solution. It's reasonable. It's also the exact approach the team tried two weeks ago and abandoned. A constraint in the data model made it unworkable.
The agent suggests it anyway. Not because it's wrong. Because it has no memory of that failure.
The Reality
The Context Problem Nobody Is Talking About
You start a new session in Claude Code, Cursor, or Copilot. The agent knows nothing. You paste the architecture, re-explain decisions, restate constraints. You have done this before.
By context, I mean the decisions, constraints, and reasoning that shape how the system actually works. Not the code itself, but the thinking behind it.
There are three ways people try to deal with this. None of them scale.
No system at all. You are the memory. Every session starts from scratch, and the agent is only as good as what you remember to include.
A static file. A CLAUDE.md, a context doc or something meant for general rules but often stretched to hold evolving decisions. It works briefly, then it drifts. It does not know about the decision you made last Tuesday. The agent doesn't know it's outdated. It produces confident, but wrong, decisions.
Stale context is often worse than none. The agent doesn't know it's outdated. It reasons from it as if it were current.
Session summaries. Better, but still limited. Every summary compresses. Details drop. Nuance flattens. After a few sessions, you are working from a summary of a summary. The original reasoning still exists. It is just no longer usable.
Now multiply this by a team. Multiple engineers, multiple tools, dozens of sessions a week. Each person rebuilding context independently. The same decisions explained again and again. The same constraints rediscovered instead of reused. This is not just inefficient. It leads to repeated mistakes and inconsistent systems.
The tools are not the limitation. They are already capable. What is missing is the layer beneath them. One that accumulates context across sessions, that any agent can read from and write to, and that preserves not just what was decided, but why it held up.
The Workarounds
What's Already Being Tried
It's not like teams aren't thinking about this. They are. The context problem is obvious enough that everyone who hits it starts looking for a fix immediately. The fixes just don't quite work.
The first thing most teams try is a rules file. A CLAUDE.md, a system prompt, a working agreement document. This does something real. It aligns agents on constraints, conventions, tone. But it captures how agents should behave, not what the system has learned. It doesn't know that you tried this approach three weeks ago and abandoned it. It doesn't know the API is flaky, or that the strategy shifted halfway through. That's not context. That's configuration.
So some teams go further and try to maintain a living document. A context.md, handoff notes, session summaries written by hand. This is closer. And it works, for a while, with enough discipline. But discipline degrades under pressure. The document gets updated when things are slow and skipped when things are urgent. That's exactly when accurate context matters most. Optional context is as good as no context.
Then there's tool-native memory. Tools like ChatGPT remember some preferences. Gemini carries forward some context. These feel promising until you realize the memory is scoped to one user, one tool, one conversation. It doesn't travel. What your agent figured out yesterday simply doesn't exist today unless you carry it yourself. Your teammate's agent doesn't share what yours learned. Each tool becomes its own small island of partial memory.
Some teams reach for knowledge bases. Notion, Confluence, an internal wiki. These solve the sharing problem. Anyone can read them, they persist, they're visible across the team. But an agent doesn't naturally write back to Notion after making a decision. Nobody updates Confluence mid-task. These systems are where context goes to rest, not where it lives. They're snapshots. The work happens somewhere else.
Across all of these, the same thing happens. Each approach holds onto one piece and drops the rest. Something is always missing, and you compensate for it manually. You re-explain. You re-decide. You rebuild context from scratch.
What's missing isn't effort. Teams are trying. What's missing is the right abstraction: something that treats context not as documentation to be maintained, but as infrastructure the system depends on.
The Missing Piece
What the Right Approach Looks Like
If you take all of these attempts seriously: rules files, handoff notes, tool memory, knowledge bases. They're all reaching for the same thing: a place where context accumulates.
Not inside a session. Not inside a tool. Not inside a document someone has to remember to update. Something that sits underneath all of it. Something the system depends on.
For that to work, it has to be shared. Not tied to one person or one workflow. If one agent learns something, another agent should be able to use it. Otherwise the problem just reappears somewhere else.
It has to persist. Not as a snapshot, but as a continuous record of decisions and constraints over time. Not reset every session. Not rewritten from memory. Built up, piece by piece, as the system evolves.
It has to be writable. Not just something agents read from, but something they contribute to. Decisions shouldn't disappear at the end of a session. If an approach fails, if a constraint is discovered, if a tradeoff is made, that should become part of the system's context without relying on someone to document it.
And it has to exist across tools. The agent you use today and the one you use tomorrow should not live in different realities. Context should not be locked inside a single interface.
Up to this point, this sounds like a better database. Or a better wiki. But that's not enough.
Because most of what happens during development is not worth keeping. If everything is stored, nothing is useful. Context turns into noise. The signal disappears under a pile of partial ideas, outdated assumptions, and abandoned paths.
So the system has to be selective. Not everything becomes context. Only the parts that hold up: the decisions that survive, the constraints that continue to matter, the patterns that prove useful more than once.
Context isn't a log. It's a filter.
And that changes the nature of the problem. You're no longer just storing information. You're deciding what deserves to remain.
The Catch
What Makes This Hard
Up to this point, the idea sounds straightforward. A shared, persistent, writable layer where context accumulates. But as soon as you try to build it, the problem shifts.
Storing context is easy. Deciding what to keep is not.
Every session produces potential context. Decisions, attempts, failures, partial ideas. If you capture all of it, the system quickly collapses under its own weight. What was meant to help starts getting in the way.
So you have to choose. What gets stored. What gets ignored. What replaces something that already exists. That decision is not mechanical.
Consider a simple case. An agent tries an approach, and it fails. That seems worth keeping. But why did it fail? Was it a real constraint, or just a limitation of that moment? Should that failure block future attempts, or just inform them?
Now consider the opposite. An approach works. It gets stored. Later, the system changes. That decision is no longer valid. How does the system know it should be updated, or removed?
This is where most approaches break down. They treat context as something you append to. A growing log of what happened. But logs don't age well. They accumulate contradictions, outdated assumptions, and noise. Over time, they become harder to use than having no context at all.
What you need is not a log. It's something that can evolve.
Something that keeps what still holds, discards what no longer applies, and reconciles conflicting information. At that point, it stops looking like a document. It starts to look more like a structure. A set of decisions connected to each other, updated over time, with some paths reinforced and others abandoned.
And that introduces a new problem. Not just storing context. Not just sharing it. But continuously evaluating it.
The Trap
The Signal vs Noise Problem
If the system has to continuously evaluate context, the next question is obvious. Evaluate based on what?
Most of what happens during development is noise. Half-formed ideas, quick experiments, workarounds that only exist for a few hours. If you store all of it, the system becomes unusable. If you ignore too much, you lose the very context you were trying to preserve.
The difficulty is that signal doesn't announce itself. A failed approach might be noise. Or it might be a real constraint that will matter again later. A decision that worked today might become irrelevant tomorrow. A workaround might quietly turn into a dependency. You don't know at the moment it happens. And that's the problem. Context has to be evaluated while the work is still in motion. Before outcomes are fully clear. Before you know what will matter and what won't.
Too early, and you keep the wrong things. Too late, and the reasoning is already gone.
Most systems avoid this by pushing the responsibility back to the user. Summarize this. Update that. Decide what matters. But that's exactly the failure mode you started with. The system depends on manual judgment, so context becomes inconsistent and incomplete.
So you try to automate it. But automation has its own failure mode. It treats everything as equally important, or relies on shallow signals like frequency or recency. What gets stored is not what matters, but what happens often enough to be noticed.
Over time, the system fills with context that looks relevant but isn't. Outdated assumptions sit next to current ones. Partial decisions appear as if they were final. The signal is still there, but it's buried.
At that point, context stops helping. It starts misleading.
And that brings you back to the original problem. Agents make reasonable decisions based on the information they have. The difference is that now, the information itself is unreliable.
The system didn't forget.
It remembered the wrong things.
The Start
What Comes Next
This is not a solved problem. Most of the difficulty sits in the evaluation layer deciding what gets kept, what gets updated, and what gets forgotten.
That's what I'm experimenting with.
Not as a finished system, but as a direction. Something that sits underneath tools, accumulates context over time, and tries to make it usable across agents and workflows.
I'll be building and testing ideas in public, iterating on how context can be captured without friction, how it can evolve without drifting, and how to preserve signal without accumulating noise.
This is the first piece.