Achieving Shared Agentic Memory Across AI Coding Tools with Hooks and Neo4j

This Q&A explores a novel approach to giving AI coding assistants—like Claude Code, Codex, and Cursor—a persistent, unified memory across different tools. By implementing hooks that connect to a Neo4j graph database, developers can achieve consistent agentic memory without being locked into any single platform. Below, we answer key questions about how this works and why it's beneficial.

1. What is unified agentic memory and why does it matter for AI coding assistants?

Unified agentic memory refers to a shared, persistent memory system that AI coding assistants can access and update across different sessions and tools. Instead of each tool maintaining its own isolated context, agents like Claude Code, Codex, and Cursor can recall past interactions, project structures, and user preferences through a common memory layer. This matters because it enables continuity: an AI can remember decisions made in a previous session even when using a different assistant. It also reduces redundancy—users don't need to re-explain project context. The memory is stored in a Neo4j graph database, which organizes information as nodes and relationships, making it easy to query complex connections. Ultimately, unified agentic memory creates a more fluid and intelligent development experience, where AI tools become collaborative partners that build on shared knowledge over time.

2. How do hooks enable persistent memory across different AI coding tools?

Hooks are lightweight callbacks or interceptors that run at specific points in a tool's workflow—for example, before a code execution or after a response is generated. By attaching a hook to each AI coding assistant (Claude Code, Codex, Cursor), developers can funnel contextual data into a central Neo4j database. The hook captures relevant information like user queries, code changes, errors, or decisions, then writes that data as nodes and edges in the graph. When the same or a different tool starts a new session, its hook first queries Neo4j to retrieve prior context. This happens in real time, without modifying the core tool. The hook system is tool-agnostic; it simply listens for events and interacts with the graph database. This decoupled design means any AI coding tool that exposes an event or extension point can be integrated, achieving persistent memory across disparate platforms.

3. Which AI coding tools benefit from this hook-based memory approach?

Three primary tools benefit directly: Claude Code (by Anthropic), Codex (by OpenAI/GitHub Copilot), and Cursor (an AI-first IDE). Each of these tools generates code, answers questions, and assists with debugging—but normally they operate without sharing context. With hooks, all three can read and write to the same Neo4j memory store. For example, a developer might use Claude Code to brainstorm architecture, then switch to Cursor to implement code, and later ask Codex to review—all while maintaining a coherent memory of the project's evolution. Other AI coding assistants that support extensions or plugins could also be integrated. The key requirement is the ability to attach a hook that can make network calls to Neo4j. This approach is especially valuable for teams that use multiple tools or want to avoid dependency on a single vendor's memory implementation.

4. What role does Neo4j play in providing persistent memory for these tools?

Neo4j is a graph database that stores information as nodes (entities like files, functions, users) and relationships (connections like 'depends_on', 'created_by', 'modified_in'). For agentic memory, Neo4j holds a rich, structured history of interactions. Unlike traditional relational databases, Neo4j excels at traversing complex relationships—for instance, finding all code files that a user edited after a specific conversation. When a hook writes to Neo4j, it can capture not just data but context: which tool was used, what the user intent was, and how pieces relate. Reading from Neo4j allows an AI assistant to retrieve relevant past information quickly, using Cypher queries. This graph-based approach is ideal because agentic memory is inherently relational—decisions chain together, files depend on each other, and user preferences interact with project constraints. Neo4j's flexible schema allows the memory to evolve without migration headaches, making it a perfect fit for persistent, cross-tool memory.

5. How does this approach avoid locking users into a single AI coding tool?

By decoupling memory from the tool itself. In typical setups, each AI assistant stores context only within its own session or proprietary cloud storage—making it nearly impossible to share or migrate memory. With hooks, the memory lives in an external Neo4j database that all tools can access. If a developer decides to stop using Claude Code and switch entirely to Codex, the memories already built remain accessible. Likewise, they can use a new AI coding tool that supports hooks without losing prior context. This vendor-agnostic design prevents lock-in because the memory is owned and controlled by the user or team, not by any single AI provider. Additionally, Neo4j is an open-core platform, further reducing dependency. The hooks themselves are open-source or easily customizable, so developers can adapt them to any tool that offers an extension point. This freedom ensures that investments in building agentic memory are not tied to a specific assistant's lifecycle.

6. What are the practical benefits of using a graph database for agentic memory?

• Flexible schema: Graph databases handle evolving data structures without needing migrations, ideal for organic memory growth.
• Relationship queries: Quickly answer questions like 'Which file was most frequently edited after discussions about performance?' using Cypher.
• Context richness: Store not only facts but also connections—e.g., linking a user's question to the resulting code change.
• Real-time access: Neo4j supports fast reads and writes, so hooks can update memory without noticeable latency.
• Scalability: As the memory corpus grows, graph databases maintain performance for complex traversals, unlike flat tables.

These benefits translate into an AI assistant that better understands project evolution, reduces repetitive interactions, and can even surface cross-tool insights—like noticing that a bug fix in Cursor originated from a design discussion in Claude Code. The graph structure also enables advanced features like memory summarization and concept clustering.

7. How can developers implement this hook system for their own workflows?

Implementation involves three steps: setting up Neo4j, writing hooks, and integrating with each AI tool. First, deploy a Neo4j instance (local or cloud) and define a simple graph schema—nodes like Session, File, Decision and relationships like led_to. Second, create hooks—small scripts (Python, JavaScript) that connect to Neo4j using its driver. For Claude Code, use the hooks configuration in its settings; for Codex, leverage API callbacks or VS Code extension hooks; for Cursor, use its plugin system. Each hook listens for events (e.g., after a response) and writes a structured record to Neo4j. Third, test the read cycle: when a tool starts a new session, its hook queries Neo4j for relevant past context and injects it into the system prompt. Open-source examples exist on GitHub for reference. It's important to define a clear schema early to avoid data clutter. With this setup, developers gain a powerful persistent memory that works across their favorite AI coding assistants.