AI Cross-Session Memory: How Knit Rethinks Context

The Forgetting Problem That Plagues Every AI Coding Session

Every developer using Claude Code, GitHub Copilot, or similar AI coding assistants has experienced the same frustrating ritual: starting a new session and watching the AI forget everything it learned yesterday. A new project called Knit proposes a fundamentally different approach to AI memory — replacing static documentation with dynamic event trees that evolve alongside your project.

The concept tackles what may be the single biggest friction point in AI-assisted development today: the gap between a project's continuous evolution and an AI's session-bound amnesia. While current workarounds like CLAUDE.md files and .claude/ directories offer partial solutions, they introduce their own set of problems that scale poorly as projects grow.

Key Takeaways

• Current AI memory solutions like CLAUDE.md are static snapshots that require manual maintenance and quickly become outdated
• Knit introduces event trees — dependency-aware data structures that automatically track decisions, progress, and context across sessions
• The core problem is that projects evolve continuously, but AI memory does not
• Decision lineage is preserved, so the AI knows not just what to do, but why previous choices were made
• Document bloat is eliminated by structuring memory as queryable events rather than growing text files
• The approach mirrors how version control transformed code management — applying similar principles to AI context management

Why CLAUDE.md Files Are Breaking Down

Developers working with Claude Code typically maintain a CLAUDE.md file at the root of their project. This markdown file contains project conventions, architecture decisions, coding standards, and progress notes. Anthropic designed this system to give Claude persistent context about the codebase it's working with.

But the approach has 4 fundamental flaws that become increasingly painful as projects mature:

• Memory is static: Whatever you manually write into the document stays frozen. After 2 weeks of active development, your CLAUDE.md might still reflect Day 1 assumptions
• Decisions are fragmented: When the AI recommends PostgreSQL over MySQL in one session, that reasoning vanishes in the next — unless you manually document it
• Context is isolated: The AI knows the current task but lacks upstream awareness — what constraints exist, what trade-offs were already evaluated, and why certain paths were rejected
• Documents bloat over time: As teams diligently add information, memory files grow longer, information density drops, and both humans and AI struggle to extract what's relevant

The core contradiction is elegant in its simplicity: software projects are living, evolving organisms, but AI memory is a manually maintained photograph. By the time you update the photo, the subject has already changed.

How Knit's Event Tree Architecture Works

Knit's proposed solution replaces flat documentation with a dependency-aware event tree — a structured graph where every project decision, milestone, and context shift is recorded as a node with explicit relationships to other nodes.

Imagine building a user authentication system. Instead of a growing text file, Knit would maintain a tree structure like this:

• Project Goal: Build user authentication system
• Tech Selection (completed): Chose JWT + PostgreSQL
  • Decision context: evaluated 3 options, selected for scalability
• Schema Design (completed): Users table with bcrypt hashing
  • Depends on: Tech Selection decision
• API Implementation (in progress): REST endpoints for auth flow
  • Depends on: Schema Design, Tech Selection
  • Constraint: must support OAuth 2.0 per stakeholder requirement

Each node carries its own metadata — status, dependencies, decision rationale, timestamps, and constraints inherited from parent nodes. When the AI starts a new session, it doesn't read a wall of text. It traverses a structured tree, understanding not just what the project looks like now, but how it got there.

Decision Lineage Solves the 'Why' Problem

One of the most underappreciated problems in AI-assisted development is the loss of decision rationale. Current systems tell the AI what exists in the codebase, but rarely explain why things are the way they are.

This matters enormously in practice. When a developer asks the AI to add a caching layer, the AI needs to know that the team previously rejected Redis in favor of in-memory caching due to infrastructure constraints. Without this context, the AI might confidently recommend the exact solution the team already evaluated and discarded.

Knit's event tree preserves this lineage automatically. Every decision node can reference the alternatives that were considered, the criteria used for evaluation, and the constraints that influenced the outcome. When the AI encounters a related task in a future session, it can trace the dependency graph backward to understand the full decision history.

This is conceptually similar to how git blame works for code — but applied to project-level decisions and architectural choices. Just as git transformed code management by making every change traceable, Knit aims to make every project decision traceable for AI consumption.

How This Compares to Existing Memory Solutions

The AI coding assistant market has been actively experimenting with memory and context management. Comparing Knit's approach to existing solutions reveals where the current ecosystem falls short.

Anthropic's Claude uses CLAUDE.md files and the .claude/ directory structure. This approach is simple and human-readable but entirely manual. It works well for small projects but degrades as complexity increases.

OpenAI's ChatGPT introduced persistent memory in early 2024, allowing the model to remember facts across conversations. However, this memory is flat — a list of facts without relationships or dependencies. It's better suited for personal preferences than complex project management.

Cursor and Windsurf use codebase indexing to maintain context. These tools excel at understanding what code exists but don't capture the decision-making process behind it. They know the 'what' but not the 'why.'

Knit's event tree approach differs by treating memory as a structured, relational dataset rather than flat text or simple key-value pairs. The closest analogy might be a project management tool like Jira or Linear — but designed specifically for AI consumption rather than human task tracking.

Practical Implications for Developers

If the event tree approach proves viable, it could fundamentally change how developers interact with AI coding assistants. Several practical benefits emerge:

• Onboarding new team members becomes faster because the AI can explain not just the current architecture but the full decision history
• Context switching between projects becomes seamless — the AI loads the relevant event tree and immediately understands where things stand
• Technical debt tracking becomes automatic as the tree records deferred decisions, known compromises, and planned refactoring
• Code review quality improves because the AI understands the intent behind changes, not just the diff

For teams using Claude Code in production workflows, this could mean the difference between spending 10 minutes re-establishing context at the start of each session versus diving immediately into productive work. Across a team of 5 developers running 3-4 AI sessions daily, that's potentially 3-4 hours of recovered productivity per day.

Challenges and Open Questions

The event tree concept is compelling, but several challenges remain unresolved. Storage and retrieval efficiency is a concern — as projects grow, the event tree could become large, and the AI needs to quickly identify which nodes are relevant to the current task.

Automatic event capture is another hurdle. If developers must manually create event nodes, the system risks becoming just another documentation burden. The value proposition depends heavily on the AI's ability to automatically identify and record significant decisions during sessions.

There's also the question of multi-agent coordination. As AI coding workflows increasingly involve multiple specialized agents, the event tree needs to support concurrent reads and writes without conflicts — essentially requiring a version control system for AI memory itself.

Looking Ahead: Memory as Infrastructure

The broader trend is clear: AI memory is evolving from a nice-to-have feature into critical infrastructure. Anthropic, OpenAI, and Google are all investing heavily in context management. The release of Claude's 200K token context window and Google Gemini's 1 million token window represent brute-force approaches — fitting more information into a single session.

Knit represents a complementary, more surgical approach: rather than expanding the window, structure the information so less context is needed to achieve the same understanding. This mirrors the evolution of databases from flat files to relational systems — a transition that unlocked entirely new categories of software.

Whether Knit specifically succeeds or not, the problem it addresses is real and growing. As AI coding assistants move from novelty to daily workflow tool for millions of developers, the demand for persistent, intelligent, structured memory will only intensify. The teams that solve this problem effectively will define the next generation of developer tooling — and potentially reshape how humans and AI collaborate on complex, long-running projects.