Breaking Free from Vendor Lock-In: Unified Agentic Memory Across AI Coding Assistants with Hooks and Neo4j

Introduction

In the rapidly evolving landscape of AI-assisted software development, tools like Claude Code, Codex, and Cursor have become indispensable. However, a critical challenge persists: each assistant operates in isolation, with its own context window and no shared memory. This leads to repetitive explanations, lost history, and a fragmented workflow. Enter unified agentic memory—a concept that allows these coding agents to share a persistent, evolving memory base across different harnesses. By leveraging hooks and a Neo4j graph database, developers can create a cohesive memory layer without being locked into a single tool.

What Is Agentic Memory?

Agentic memory refers to the ability of an AI agent (like a coding assistant) to retain and recall information from past interactions. Traditional implementations use vector databases or simple key-value stores, but these often lack the relational depth needed for complex development tasks. A graph database like Neo4j excels here because it models relationships between code entities, project structures, developer intents, and historical decisions. Instead of a flat list of facts, agentic memory becomes a web of interconnected knowledge—a true knowledge graph.

The Problem of Vendor Lock-In

Most AI coding tools provide their own memory mechanisms, but they are proprietary. For example, Claude Code keeps a local context cache, Codex relies on OpenAI’s thread management, and Cursor maintains its own session state. Switching tools means losing that accumulated context. Worse, using multiple tools simultaneously forces developers to manually re-explain tasks. This fragmentation reduces productivity and ties teams to a single ecosystem. The industry needs a vendor-agnostic approach that works across harnesses.

How Hooks Enable Unified Memory

The key lies in hooks—intercept points in the tool’s execution flow that allow custom code to run before or after specific events. Most modern AI coding assistants expose hook APIs (e.g., pre-query, post-response, file-open). By implementing a hook that records every interaction—queries, generated code, user corrections—you can build a shared memory log. The hook sends this data to a central storage layer. The same hook also retrieves relevant past memories when a new query is made, injecting them as context.

Implementing with Neo4j

Neo4j is the ideal backend for this unified memory because it naturally represents the graph-like structure of software projects. Here’s a high-level implementation outline:

• Data Model: Create nodes for users, projects, files, functions, bugs, and decisions. Define relationships like USES, DEPENDS_ON, FIXED_BY.
• Hook Registration: Write a lightweight hook script for each tool (Claude Code, Codex, Cursor). The script captures input prompts, output responses, file changes, and user ratings.
• Memory Insertion: When the hook fires, it sends a JSON payload to a small API server that updates the Neo4j graph—adding new nodes or relationships as needed.
• Context Retrieval: Before a new query, the hook queries the graph for relevant memories (e.g., “what was the last error in file X?” or “which design pattern was used for module Y?”). The retrieved context is appended to the prompt.
• Feedback Loop: Allow users to confirm or reject retrieved memories, refining the graph over time.

Benefits of a Unified Memory Layer

No Data Silos

With hooks feeding into Neo4j, every interaction—whether from Claude Code, Codex, or Cursor—enriches the same knowledge graph. Ask a question in one tool, and the answer is remembered across all others.

Contextual Continuity

Developers can switch between harnesses without losing track of ongoing tasks. The memory includes code changes, bug fixes, and even rationales behind design decisions.

Improved Code Quality

Because the graph captures dependencies and historical fixes, the AI can suggest more accurate refactors and prevent regression. It learns from past corrections made in any tool.

Future-Proof Flexibility

When a new coding assistant emerges, you only need to write a small hook adapter. The memory already exists in Neo4j, so the new tool immediately benefits from accumulated knowledge.

Practical Example

Imagine you are working on a Python project. You use Cursor to refactor a module. Later, you switch to Claude Code to debug a related error. Without unified memory, Claude Code has no idea about the refactor. With hooks and Neo4j, when you ask for help, the hook retrieves: “The user recently refactored module_a.py—the new structure is …” and injects that into the prompt. Claude Code then provides context-aware debugging assistance.

Conclusion

Unified agentic memory is not just a convenience—it’s a necessity for teams that rely on multiple AI coding assistants. By implementing hooks that write to and read from a shared Neo4j graph database, you break free from vendor lock-in while preserving all the benefits of persistent memory. This architecture is scalable, extensible, and respects data ownership. Start small: pick one tool, write a simple hook, store in Neo4j, then expand to others. The result is a seamless, intelligent development environment that learns across every interaction.

If you’re interested in the technical details, check out the full implementation guide on the Neo4j developer blog. And for a deeper dive into agentic patterns, see our post on graph-based memory for AI agents.