Supported editors

aide-memory was originally built for Claude Code and expanded to Cursor and Devin CLI. All three have full hook + MCP wiring at aide-memory init. Codex, Copilot, and Windsurf ship a rules template today; deeper integration may come based on user feedback.

These editors may need a fresh session (or restart) after aide-memory init so the MCP server registers. Cursor adds a second step: toggle the aide-memory MCP server ON in Settings → MCP.

Devin CLI’s hook system is Claude-Code-compatible, so aide-memory runs there at near-Claude-Code parity; the few differences (soft-only pre-tool nudges, no branded chrome, PostCompaction, skill-based teaching) are documented on the Devin editor page.

Legend

✅ supported
❌ not supported
⚠ partial support (see footnote)
📝 rule template only (no hook / MCP wiring yet)

Per-editor table

Capability	Claude Code	Cursor	Devin CLI	Codex	Copilot	Windsurf
`aide-memory init` generates editor config files	✅	✅	✅	📝	📝	📝
MCP tools available in agent sessions	✅	✅ ¹	✅ ¹	⚠ ¹	⚠ ¹	⚠ ¹
Hard-block on file read with scoped memories	✅	✅ ²	⚠ ³	❌	❌	❌
Hard-block on file edit with scoped memories	✅	✅	⚠ ³	❌	❌	❌
Soft nudge on re-read (agent-context channel)	✅	✅ ⁴	✅	❌	❌	❌
Inline branded status on hard-block	✅	✅	❌ ⁵	❌	❌	❌
Inline branded status on soft-nudge	✅	⚠ ⁶	❌ ⁵	❌	❌	❌
Session-start dynamic context injection	✅	⚠ ⁷	✅	❌	❌	❌
Session-start context after compaction	✅	❌ ⁸	⚠ ⁹	❌	❌	❌
Stop-hook reflection nudges	✅	✅ ¹⁰	✅	❌	❌	❌
Correction detection (UserPromptSubmit / beforeSubmitPrompt)	✅	⚠ ¹¹	✅ ¹²	❌	❌	❌
Pre-search nudge on Grep	✅	✅	✅	❌	❌	❌
Pre-search nudge on Glob	✅	❌ ¹³	✅	❌	❌	❌
Auto-regenerated rule file on memory/config writes	⚠ ¹⁴	✅	⚠ ¹⁵	❌	❌	❌

Current state

Claude Code is the reference adapter. All capabilities listed here work as designed.

Cursor ships with aide-memory at strong parity with Claude Code. aide-memory init writes .cursor/hooks.json, .cursor/mcp.json, and .cursor/rules/aide-memory.mdc (the last one auto-regenerates on memory and config changes). Soft nudges reach the agent via agent_message, hard blocks render branded chrome inline. Remaining gaps are documented on the Cursor editor page.

Devin CLI ships with aide-memory at near-Claude-Code parity, since Devin’s hooks are Claude-Code-compatible. aide-memory init writes a single .devin/config.json (hooks + MCP server) plus a .devin/skills/aide-memory/SKILL.md skill — all scoped to .devin/, leaving your AGENTS.md untouched. Recall nudges, session-start injection, in-turn correction detection, the Stop checkpoint, and the full MCP tool surface all work. The main differences: pre-tool nudges are soft (Devin’s hard block is non-recoverable), there’s no branded status chrome (aide-memory shows via MCP tool-call cards), and compaction uses PostCompaction. Details on the Devin editor page.

Codex, Copilot, Windsurf ship a curated rule template today. Deeper integration may come based on user feedback. To request it, open an issue.

Per-editor pages

Claude Code, reference UX, branded chrome, in-turn correction detection, full hook parity
Cursor, hard-block + soft-via-agent_message, rules-file session context, one-turn-delay corrections, per-Read editor-open coverage gap
Devin CLI, Claude-Code-compatible hooks, soft-only pre-tool nudges, skill-based teaching, in-turn corrections, PostCompaction, MCP tool-card visibility
Windsurf, rule template only
Codex, rule template only
Copilot, rule template only

Footnotes

Cursor’s MCP config is generated at init. Codex / Copilot / Windsurf ship a rules template only. If you add aide-memory as an MCP server manually in the editor’s own MCP config, the seven tools work identically to Claude Code. ↩ ↩² ↩³ ↩⁴ ↩⁵
Cursor 3.2.11’s preToolUse:Read hook does NOT fire when the target file is already open in the editor pane (verified empirically 2026-04-27). Files that are NOT open trigger the hook reliably. preToolUse:Write (Edit) fires regardless of editor-open state. Mitigation: per-Edit safety net stays reliable, and the rules-file injection includes “Even when a file is visible to you, call aide_recall for that path” guidance so agents pick up memories on editor-cached reads. The mitigation is empirically verified across the 4-cell file-open validation matrix. ↩
On Devin a PreToolUse decision: "block" is terminal — it shows ✗ Tool blocked: <reason> to the user but ends the agent’s turn rather than feeding the reason back for recall-and-retry (verified live, even with imperative reasons). Since the block isn’t recoverable, aide-memory never hard-blocks reads/edits on Devin; it delivers the “call aide_recall” signal through the soft additionalContext channel, which doesn’t stop the turn. The agent recalls and continues. (The Stop checkpoint still uses decision: "block", where blocking means “don’t stop, reflect”.) ↩ ↩²
Soft nudges are delivered via Cursor’s agent_message field on permission: "allow", the equivalent of Claude Code’s additionalContext channel. The agent receives the same context payload (memory IDs + recommended tool call) on every fire. Verified empirically on Cursor 3.2.11 (2026-04-27). User-visible chrome on soft fires is the remaining partial gap. ↩
Devin does not render aide-memory’s systemMessage “aide-memory · …” status lines. aide-memory activity is visible instead through Devin’s native MCP tool-call cards (e.g. ⏺ Called aide_recall from aide-memory with arguments and returned memories). hooks.visible has no effect on Devin. ↩ ↩²
On permission: "deny" (hard-block), Cursor renders user_message chrome inline in chat: the user sees aide-memory · ... status lines just like Claude Code. On permission: "allow" (soft fire), Cursor 3.2.11 logs user_message to the Hooks Output panel but does NOT render it inline in chat. The agent still receives the soft context via agent_message on every fire, so the safety net works; only the user-facing visibility for soft fires is missing. ↩
sessionStart.additional_context is broken on Cursor (staff-confirmed, no workaround). aide-memory delivers the same content via a dynamically regenerated .cursor/rules/aide-memory.mdc with alwaysApply: true, Cursor staff’s officially-endorsed workaround. Content identical, channel different. ↩
Cursor’s sessionStart hook does not re-fire after context compaction. The regenerated rules file partially covers this since Cursor re-reads alwaysApply: true rules each turn, but the dedicated session-start pipeline (that Claude Code gets) is not available. ↩
Devin fires PostCompaction (after compaction completes), not Claude Code’s PreCompact. aide-memory clears its per-session recall tracking there so the agent re-recalls fresh after a compaction; there’s no automatic re-injection of session-start content (Devin’s compaction lifecycle differs from Claude Code’s SessionStart source: "compact"). ↩
Stop-hook nudges use Cursor’s followup_message channel instead of Claude Code’s systemMessage. Same effect, different transport. ↩
Cursor detects corrections via beforeSubmitPrompt and writes the same correction-pending flag Claude Code does, but Cursor’s beforeSubmitPrompt hook output supports only continue + user_message, no context injection channel. The user-visible “store this correction” reminder therefore arrives one turn later via the next Stop hook’s followup_message. ↩
Devin injects UserPromptSubmit additionalContext in-turn, so the agent can call aide_remember in the same turn the correction was typed — no one-turn delay (unlike Cursor’s beforeSubmitPrompt, which delivers the reminder on the next Stop). ↩
Cursor’s documented matcher vocabulary is Shell, Read, Write, Grep, Delete, Task, MCP:<tool>, no Glob matcher. The adapter skips Glob silently. Grep coverage is unaffected. ↩
Claude Code does not need rules regeneration because its SessionStart hook can inject dynamic context directly. The regen pipeline exists for Cursor specifically; Claude Code’s .claude/rules/aide-memory.md is a static template. ↩
Devin doesn’t need rules regeneration for the same reason as Claude Code — its SessionStart hook injects dynamic context directly. The teaching ships as a static .devin/skills/aide-memory/SKILL.md skill plus a SessionStart-injected pointer. ↩

Hooks Claude Code