TL;DR
- Glen documents session-capture plugins for Claude Code, Codex, Cursor, and Pi. What each plugin records varies by agent.
- Plugin hooks record supported sessions. Other MCP-compatible clients can search Glen memory, but MCP access alone does not record sessions. Retrieval also requires a search rather than guaranteed recall on every turn.
- The handoff test will record a decision in one supported agent, search for its source memory, and retrieve it from another. It will not assume immediate indexing.
- Editors are a separate question from agents. Glen has no native extension for VS Code, GitHub Copilot, or JetBrains; the compatibility section covers what works in each.
What Glen records versus what it only searches
Glen’s agent plugins record sessions through hooks, while a generic MCP connection does not automatically capture them. In Claude Code, a UserPromptSubmit hook sends the prompt, previous reply, and workspace context to Glen and fetches matching memory for the turn. A Stop hook records the finished response, thinking, tool calls, and tool results. Those results may include file contents or command output, so check what a session contains before treating it as private scratch work.
Capture varies by agent. Codex records the prompt and final reply at Stop, rather than the full tool transcript. Cursor records prompts and replies through its agent hooks, but its agent must run glen search to retrieve memory on demand. Pi can add matching memory before an agent turn and records the prompt and final answer when the agent settles. A recorded session therefore may contain different evidence depending on which agent produced it.
An MCP connection gives another compatible client access to Glen tools, including glen_search for existing memory and glen_import for explicitly importing past conversations. Connecting a client does not install session-capture hooks. Search answers cite source memories, which you can inspect before relying on a recalled decision.
Editors are a separate question from agents. A Glen plugin for an agent does not make every editor that agent runs in a Glen integration, and an MCP connection in an IDE gives search, not capture. Check the client-specific documentation before relying on capture or retrieval.
Setting up Claude Code
Glen’s Claude Code integration requires a Glen account, Claude Code, and Node.js. Install the CLI, sign in, and install the plugin for Claude Code.
npm install -g @tryglen/cli
glen login
glen install --agent claude
Start a new Claude Code session after installation. If you prefer to install the plugin manually, use Claude Code’s plugin marketplace commands instead.
claude plugin marketplace add Glen-Web-App/glen-claude-code-plugin
claude plugin install glen@glen
Claude Code’s UserPromptSubmit hook sends Glen your prompt, the previous reply, and workspace context, then fetches matching memory for that turn. Its Stop hook records finished text, thinking, tool calls, and tool results. Those results may contain file contents or command output, so check what your sessions expose before using the integration with sensitive work. A Bash hook also links commits to the session. If capture does not appear to work after you start a new session, run glen doctor to check the installation.
Setting up Codex
Install Glen’s CLI, sign in, and install the Codex integration.
npm install -g @tryglen/cli
glen login
glen install --agent codex
The installer writes Codex hooks to ~/.codex/hooks.json and registers trust in ~/.codex/config.toml. In Codex, run /hooks to check and approve the hooks. If sessions are not recording, run glen doctor and check /hooks again. An untrusted hook can leave the installation in place without recording your session.
Codex’s UserPromptSubmit hook retrieves matching memories when you submit a prompt. Its Stop hook records the prompt and final reply, not the full tool transcript. By comparison, Claude Code’s Stop hook also records thinking, tool calls, and tool results. Keep that difference in mind when you expect Glen to find a decision that appeared only in a tool output.
Setting up Cursor
Cursor’s Glen plugin requires Cursor with agent hooks enabled and Node.js. Install the Glen CLI, sign in, and add the plugin from Cursor’s agent chat.
npm install -g @tryglen/cli
glen login
In Cursor’s agent chat, run:
/add-plugin https://github.com/Glen-Web-App/glen-cursor-plugin
Start a new chat and check Glen’s status there. Run glen doctor to verify the installation and diagnose hook problems.
Cursor’s plugin records prompts through beforeSubmitPrompt and replies through afterAgentResponse. Cursor cannot inject matching memories automatically on every turn. Unlike the Claude Code and Codex integrations, retrieval in Cursor depends on the agent choosing to run glen search. To test retrieval, ask the agent to run that search for a distinctive decision recorded in an earlier session rather than assuming it will recall the decision without a search.
Setting up Pi
Install Pi and Node.js, then set up Glen for Pi with npm install -g @tryglen/cli and glen login. Run pi install npm:@tryglen/pi to add the integration. Alternatively, run glen install and let Glen detect Pi. Restart Pi or use /reload after installation. If you skip that step, the new hooks will not run in your current session.
Pi’s before_agent_start hook adds matching Glen memories to the agent’s context before it responds. After Pi finishes, agent_settled records the prompt and final answer. That capture scope does not promise a full tool transcript. To check the handoff, make a distinctive decision in a Pi session, then look for the recorded memory in Glen before searching for it from another agent.
Importing recent sessions
Glen can import sessions you ran before installing it. glen import takes paths to transcripts on your machine: Claude Code, Codex, and Pi session .jsonl files or the folders that hold them, or Cursor's state.vscdb database.
glen import ~/.claude/projects ~/.codex/sessions --dry-run
glen import ~/.claude/projects ~/.codex/sessions
glen import --status
The default locations are ~/.claude/projects for Claude Code, ~/.codex/sessions for Codex, ~/.pi/agent/sessions for Pi, and Cursor's state.vscdb under its globalStorage folder. Run with --dry-run first to list what would be imported without writing anything. The import runs in the background by default; --status shows its progress, and --wait runs it in the foreground instead. You choose the scope by choosing which files and folders to pass.
Glen’s MCP documentation also documents glen_import for importing past conversations on request from an MCP client. Connecting an MCP client alone does not automatically import or record sessions.
Testing a cross-agent decision handoff
Use this as an illustrative test, not an observed run. Glen’s coding-agent memory guide uses a billing-webhook handoff as an example. Before starting, sign Claude Code and Codex into the same Glen organization. Confirm that Claude Code’s Glen plugin is recording and that the session is not in incognito mode or otherwise turned off. Glen documents plugin-based capture for both agents.
In Claude Code, enter a distinctive decision and its reason. For example, write, “For billing webhooks, we chose the provider event ID as the idempotency key because retries can deliver the same event more than once. Store processed IDs in the database.” Ask Claude Code to restate the decision, then finish the turn. Open the Glen dashboard and find the recorded conversation. Check that its source transcript contains the decision before testing retrieval.
In Codex, ask Glen’s glen_search tool, “Why did we choose the provider event ID as the billing-webhook idempotency key, and where was that decision recorded?” Check the answer for a source citation in the form observation:<id> or message:<id>. Open the cited source and compare it with the Claude Code transcript. A matching explanation without a verifiable source does not complete the test.
Run the search after the conversation appears in the dashboard. Session capture and indexing may take time, and neither plugin capture nor MCP search guarantees that Codex will recall the decision without being asked.
Connecting other MCP-compatible clients
Glen’s canonical MCP documentation gives other compatible clients a way to search existing memory through https://mcp.tryglen.com/mcp. Use a client that supports remote MCP over Streamable HTTP. With OAuth 2.1, the client registers, you sign in, and you select your Glen organization. Glen also documents personal API keys as an authentication option.
The documented Claude Code command adds that MCP connection.
claude mcp add --transport http glen https://mcp.tryglen.com/mcp
For Cursor, the documented mcp.json entry uses the same endpoint.
{"mcpServers":{"glen":{"url":"https://mcp.tryglen.com/mcp"}}}
These MCP configurations let an agent call glen_search with a full-sentence query. Glen also offers glen_import for an import you request explicitly. Adding an MCP connection does not automatically record new sessions. Automatic session capture depends on Glen’s agent plugin and hooks, even when the client is Claude Code or Cursor.
VS Code, GitHub Copilot, and JetBrains compatibility
Glen’s setup docs verify plugins for specific coding agents, not native integrations for every editor those agents can run in. The statuses below separate a supported agent’s plugin from an editor-level integration.
| Client | Status | What the documentation supports |
|---|---|---|
| VS Code | Confirmed through a supported agent. Native integration and generic MCP search are unverified. | If you run a supported agent such as Claude Code inside VS Code, use that agent’s Glen plugin. No Glen-native VS Code extension is documented. An MCP-capable client may be able to search Glen, but that path has not been validated here. |
| GitHub Copilot | Unverified | Glen documents no Copilot plugin or automatic session capture for Copilot. MCP connectivity alone would not establish either capability. |
| JetBrains | Unverified | Glen documents no native JetBrains plugin or verified MCP authentication path. That does not establish that JetBrains cannot connect through MCP. |
None of these editors is confirmed as categorically unsupported. The unsupported claim is narrower. Glen’s documented setup does not provide a native extension for any of the three.
Glen’s VS Code page uses the same https://mcp.tryglen.com/mcp endpoint as the MCP documentation. Adding it to VS Code gives the agent there search over your team’s memory; recording comes from running a supported agent’s plugin.
When Copilot Memory or repo instructions are enough
If you work in one repository and stay in GitHub Copilot, Copilot Memory may cover what you need. On eligible paid plans, it can share repository facts with collaborators working in that repository and carry your personal preferences across repositories. Its use varies by Copilot surface and settings, so do not rely on a memory appearing in every session.
Put standing rules in repository instructions instead. Use .github/copilot-instructions.md or AGENTS.md for guidance such as test commands or code conventions that Copilot should receive in repository context. Instructions give the agent a repeatable source of guidance, although they cannot guarantee compliance.
A solo developer using one agent in one repository likely does not need Glen. Glen becomes more useful when you need to find the reasoning behind a past decision across supported agents or teammates, with a source memory you can check. Glen’s guide to coding-agent memory explains how session history, built-in memory, and repository instructions serve different purposes.
How precise integration docs compare
Supermemory’s Cursor guide names the install command, the Node.js prerequisite, and a status command for checking the connection. It also distinguishes session capture from recall and MCP access. A reader can follow the steps and check which behavior they enabled.
Pieces’ JetBrains guide gives a required IDE version, names its prerequisites, and explains how to check that its tools appear. Those details document Pieces, not Glen. The same standard applies to Glen setup claims. A verified plugin install can support a claim about session capture, while an MCP connection supports a claim about access to search tools. Import has its own command, glen import, with --dry-run to check what it will send before it sends anything.
Conclusion
Use Glen’s plugin hooks when you need session capture. Use MCP when you need to search recorded memories from another client. An MCP connection alone does not record a session or make an agent recall a decision on every turn.
Before you rely on a handoff with colleagues, record a distinctive decision in a supported agent and find its source memory. Then search for that decision from the second agent and check the citation against the source. Verify each client’s current setup and import behavior against Glen’s canonical documentation rather than assuming that support for one agent applies to another.
