If you’ve spent time working with LLM agents like Cursor/Cline/Roo, you’ve probably encountered the frustrating challenge of context preservation. These models are incredibly capable, but their “memory” resets with each session, losing all the collaborative context you’ve built together.
The common solution has been to implement memory systems. Cline’s Memory Bank is a notable example - a structured, code-centric approach that provides a mechanistic way to store and retrieve information between sessions. While effective, these approaches often feel rigid, focusing on command structures and explicit data organization that requires significant overhead.
This got me thinking: what would a less mechanistic, more collaborative approach look like? Something that could work with any project folder full of text files, where LLM agents could naturally navigate the information space without constant human direction?
After numerous iterations with Claude, what emerged was what I’m calling a “Context Network” - and I think the name fits perfectly for reasons I’ll explain.
Unlike a “memory bank” - which evokes the image of a passive storage vault where information is deposited and withdrawn through formal transactions - a context network is active, interconnected, and evolving:
Network vs. Bank: A network emphasizes the relationships between information, not just the storage of it. The magic is in the connections.
Context vs. Memory: Context is richer than memory. Memory implies simple storage and retrieval, while context encompasses relationships, relevance, perspective, and meaning.
A context network treats information as a living ecosystem rather than static records. It’s designed around explicit processes for identifying, documenting, and navigating relationships between information nodes across multiple dimensions.
What makes the context network approach different is its collaborative nature. Rather than being a system where you issue commands to store and retrieve information, it becomes a working agreement between you and your AI agents:
Co-creation: You and your agents build the context network together, establishing structure and identifying relationships collaboratively.
Evolving Knowledge: The network evolves through use, with regular retrospectives and improvements based on actual experience.
Agile Approach: Think of it as an agile working agreement, where the team (you and your agents) continuously refine how you work together.
When an interaction doesn’t go as planned, you don’t just fix the immediate issue - you have a retrospective conversation with your agent about what went wrong and how to improve the context network itself. This creates a virtuous cycle where the system gets better over time.
The context network framework is particularly well-suited for version-controlled folders of text files - the native habitat of software projects, documentation, and many other collaborative works:
Works with What You Have: No need for specialized databases or complex systems - just structured text files that can live in your existing Git repos.
Navigation, Not Storage: The focus is on creating navigation pathways through your existing information, not building separate storage systems.
Tool Integration: While designed for text files, the framework can extend to other file types if your agents have access to appropriate tools or MCP servers.
The beauty of this approach is its simplicity and flexibility. At its core, it’s about establishing patterns of relationships and navigation that make your existing information more accessible and usable.
The genesis of this framework came from a familiar frustration - having to repeatedly explain the same context to an AI assistant. But instead of just building a better storage system, this approach reframes the problem:
What if we created a systematic way for humans and AI to share understanding of complex information spaces?
The result is less about commanding an AI to remember things and more about creating shared maps of your project’s knowledge landscape that both you and your AI partners can navigate together.
This repository contains everything you need to implement context networks in your own projects:
Comprehensive Guide: The complete framework explaining what context networks are, why they’re useful, how they work, and how to build them.
Human Implementation Guide: Practical considerations for human teams implementing context networks.
Prompt Templates: Ready-to-use prompts for setting up context networks with your AI assistants.
Example Projects: Sample context networks for different project types.
Tools: Utilities to help build and maintain context networks.
The easiest way to get started is to:
Remember, this is an evolving framework. I’d love to hear about your experiences, improvements, and adaptations. Feel free to contribute back to this repository with your own templates, examples, and tools.
I believe context networks represent an important step toward more effective human-AI collaboration. Rather than treating AI as tools that need to be programmed or commanded, this framework treats them as collaborative partners who can help us navigate and maintain complex information spaces.
As our projects and knowledge bases grow increasingly complex, having frameworks that help us manage that complexity - not just for ourselves but for the AI systems we work with - will become increasingly valuable.
I’m excited to see how this framework evolves and what you build with it!
Want to contribute? Check out the contribution guidelines to get started.