Building Persistent Agentic Memory Across AI Coding Tools with Hook-Driven Neo4j Integration

Modern AI coding assistants like Claude Code, Codex, and Cursor have revolutionized how developers write code. However, each tool operates within its own memory silo—past context, preferences, and learned patterns vanish when you switch harnesses. A new approach using hooks and a shared Neo4j graph database solves this problem, providing unified agentic memory that persists across sessions and tools, without locking you into any single ecosystem.

What Is Agentic Memory and Why Does It Matter?

Agentic memory refers to the ability of an AI agent to retain and recall information across interactions. In coding assistants, this includes project context, code preferences, debugging history, and user intent. Without it, every conversation starts from scratch, wasting time and losing valuable continuity.

Traditional solutions store memory in the tool’s internal database or a simple key-value store, making it impossible to share that memory with other assistants. Developers who use multiple harnesses—Claude Code for natural language reasoning, Codex for API suggestions, Cursor for real-time editing—end up with fragmented context.

The Hook Implementation: A Lightweight Bridge

Hooks are event-driven callbacks that execute custom logic at specific points in a tool’s workflow. By inserting hooks into the AI harness pipeline, developers can intercept and process every input and output, extracting embeddings and structured data.

These hooks do not modify the core functionality of the AI tool. Instead, they act as observers, capturing:

• User queries and commands
• AI-generated code and explanations
• User corrections and feedback
• File and project metadata

The captured data is then transformed into graph nodes and relationships, sent to Neo4j via its REST or Bolt API. Because hooks are non-blocking and asynchronous, performance impact is negligible.

Neo4j: The Graph Foundation for Unified Memory

Neo4j is a native graph database that excels at storing and querying highly connected data. For agentic memory, this means representing:

• Nodes: User intents, code snippets, file paths, error patterns, learned preferences.
• Relationships: “used_in”, “followed_by”, “solved”, “preferred_in_context”, etc.

Graph traversal allows the memory system to find relevant previous interactions even when they are not directly linked by keywords. For example, if a user previously asked about a specific API pattern in a React project, that memory becomes accessible when a similar pattern appears in another harness.

Schema Design for Cross-Harness Access

A common node label MemoryEntry with properties for harness source, timestamp, content hash, and embedding vector ensures uniqueness and scalability. Relationships like HAS_PRECEDENT or RELATES_TO connect memories across harnesses, enabling true unified recall.

Implementing Hooks in Claude Code, Codex, and Cursor

Each harness exposes different integration points, but the hook principle remains the same.

Claude Code Hooks

Claude Code offers a plugin system where listeners can be attached to beforeRequest and afterResponse events. A simple Python script captures the user message and Claude’s answer, extracts code blocks, and writes a structured JSON payload to Neo4j. The hook also reads from Neo4j to inject relevant prior context into the prompt.

Codex Hooks

GitHub Copilot (Codex) can be extended via its extension API. A custom extension listens for completions and fix-ups. Whenever Codex generates code, the hook saves the context (current file, surrounding code) as a graph node. Later, when the same file is edited in Cursor, the memory system retrieves the prior Codex suggestion, saving time and reducing errors.

Cursor Hooks

Cursor, built on VS Code, provides a rich extension API. A hook for onDidChangeTextDocument and onDidSaveTextDocument captures user edits and AI suggestions. The hook also integrates with the Neo4j schema to store diff patterns. This allows Cursor to remember how the user corrected a previous suggestion, even if that suggestion came from Claude Code.

Benefits of Unified Agentic Memory

1. Seamless context switching: Start a conversation in Claude Code, request a code review in Codex, and refine in Cursor—all with shared awareness of what has been discussed and decided.
2. Reduced redundancy: The AI does not repeat explanations or suggest the same fixes already rejected, because the memory graph records negated relationships (e.g., “user_rejected”).
3. Personalized learning: Over time, the graph becomes a rich repository of user preferences, coding style, and common patterns, making all harnesses smarter collectively.
4. No vendor lock-in: You are free to adopt new AI tools. Simply write hooks for them, connecting to the same Neo4j instance. Your memory travels with you.

Implementation Considerations

Security and Privacy

All data sent to Neo4j should be encrypted in transit and at rest. Consider running a local Neo4j instance for sensitive projects, or a cloud-hosted one with strict access controls. Hooks can be configured to exclude file contents containing secrets.

Query Optimization

Use indexing on node properties like projectId and embedding_vector. For similarity search, enable the Neo4j Graph Data Science library to run cosine similarity queries between embeddings, finding relevant memories in milliseconds.

Fallback and Toggle

Not every session requires unified memory. Add a configuration toggle to enable/disable the hook. If Neo4j is unreachable, the hook silently fails, and the AI tool operates as normal—no crash, no delay.

Bringing It All Together: An Example Workflow

Imagine you are building a React component for a drag-and-drop interface. You start by describing the idea in Claude Code. The hook creates a memory node with your description, intent “build drag-drop component”, and Claude’s proposed architecture. Next, you copy the key requirement to Codex for a quick API snippet. Codex’s hook reads the Claude memory, sees the architecture, and suggests the correct event handlers. Finally, you open Cursor to implement the component. The hook pulls all prior memories—both the architectural plan and the API example—and automatically incorporates them as comments in your editor.

This workflow reduces context-switching overhead, eliminates duplication of effort, and creates a persistent learning loop that compounds with each interaction.

Conclusion

Hook-driven integration with Neo4j offers a pragmatic path to unified agentic memory across AI coding harnesses. It respects the autonomy of each tool while weaving them together through a shared, queryable knowledge graph. As AI assistants proliferate, this approach ensures that your valuable interactions are not lost—they become part of a growing, cross-harness intelligence that works for you, not the vendor.

For developers looking to implement this, start with a simple hook for one harness, then gradually expand. The flexibility of hooks and the power of Neo4j make unified memory an achievable goal today.