Last Updated: 8/20/2026

Supported AI Agents and Capture

Overview

Jolli Memory captures the reasoning behind your work automatically. On every commit, a background worker finds the AI coding session that produced the work, reads its transcript and your git diff, and attaches a structured Memory to the commit. This page lists every agent Memory can capture, how each one is captured, which surfaces can do what, and how to turn any source on or off.

Private and local-first: your summaries and transcripts are stored with your repo. Generating a summary sends your transcript and diff to the LLM for that request (never stored off-machine); nothing is published to anyone else until you Share in Jolli.

Prerequisites

• Memory enabled in a git repository (jolli enable).
• Five sources need Node 22.13 or later because they read a local SQLite database: OpenCode, Cursor’s Composer IDE, GitHub Copilot CLI, Devin, and Antigravity. The jolli CLI itself needs it too.
• Hook-based agents (Claude Code, Gemini CLI) must be restarted after enabling. Every agent needs one restart before MCP tools appear.

What “capture” means

Capture is the step where Memory turns a coding session into a stored Memory:

1. You code with an AI agent in a git repo where Memory is enabled.
2. You commit.
3. In the background, Memory finds the session that produced the work, reads its transcript and the diff, and generates the Memory.

Each Memory names the agent that produced it, so you can use more than one agent in the same repo and still tell them apart.

Memory finds your session in one of two ways, depending on the agent. Some agents run a hook that records the session as it happens. Others have no usable hook, so Memory discovers the session by reading files or a local database at commit time. Both models are explained below.

Supported agents at a glance

Memory captures thirteen sources across ten agents. Some agents have more than one capture path that shares a single toggle - GitHub Copilot, Cursor, and Cline each do. Every source is enabled automatically when its agent is detected, unless you turn it off.

Notes:

• The three shared toggles are spelled out under Turning a source on or off, below.
• “Auto briefing” means the automatic session-start briefing, covered below.

What works where

The table above is about which agents Memory captures from. This one is about the surfaces you drive Memory through, because they do not all offer the same things.

For where you can open the local dashboard from each of these, see The Local Dashboard.

JetBrains is the narrowest surface. Its skills and MCP tools need Node on your PATH; without Node the tool window shows “MCP & Skills: Node.js not found”. Memory generation still works, because it runs on native Java hooks.

The two capture models

Hook-based: Claude Code and Gemini CLI

Set Claude Code up with the plugin? The mechanism below is the same, but the plugin installs the hook itself instead of you running jolli enable. See Jolli Memory in Your AI Agent for that path, and for the Cursor and Codex plugins.

Claude Code and Gemini CLI record each session through an agent hook, installed either by jolli enable or by the Claude Code plugin. Because the hook runs inside the agent, it only loads on a start that happens after the hook is in place: if either was already running when Memory was set up, restart it or the session is not recorded.

Claude Code’s hook is the Stop hook, which records the session when a turn ends. Gemini CLI’s is an after-agent hook, and Gemini gets no session-start briefing - use Recall instead.

Discovery-based: every other source

The other eleven sources have no hook that Memory can use. Instead, Memory discovers the session at commit time by scanning the filesystem or reading a local database. There is nothing to restart for capture. As long as the agent wrote its session to the expected location and you committed within the freshness window, the session is found.

Every host does still need one restart before Memory’s MCP tools appear, because an agent reads its MCP configuration at startup. See Use Your Memory from Any AI Agent (MCP). A single full restart covers that, a capture hook loading, and - with an agent plugin - setup running at all; you never need more than one.

Per-agent notes

The table above gives each source’s session location, its toggle, and whether it needs Node 22.13+. Three details it cannot hold:

• OpenCode: if you use a non-standard data directory, set XDG_DATA_HOME so Memory can find the database.
• Antigravity’s variant folder is one of antigravity, antigravity-ide, or antigravity-cli.
• Kimi Code CLI also contributes references and captured skill usage, both covered further down this page.

Node 22.13+ prerequisite

The jolli CLI itself needs Node 22.13+, and the engines field refuses to install on anything older. The install script asks for less than that: it checks the major version only, so it accepts any Node 22 and reports success, and npm is what refuses afterwards. 22.13 is the version actually enforced. Separately, the five sources marked Yes in the “Node 22.13+?” column above read a local SQLite database using Node’s built-in SQLite support, so they too need Node 22.13+ at runtime; the other sources do not.

Node’s built-in SQLite first appears in 22.5, but until 22.13 it only loads behind a startup flag - and the two places that matter here, the VS Code extension host and the git hooks, cannot pass one. So 22.13 is the real floor for these sources, not 22.5.

• On the CLI, this is your installed Node version.
• In VS Code (or a fork such as Cursor or Windsurf), you need a build recent enough to bundle Node 22.13+, and the extension itself now requires VS Code 1.101 or later. On 1.100 and earlier the Marketplace stops offering the update, so the extension quietly stays at whatever version you already have rather than telling you it is out of date.

If the runtime is older, these five sources are reported as not detected rather than as an error. They simply will not appear in jolli status. Codex CLI, GitHub Copilot Chat, the cursor-agent CLI, Kimi Code CLI, and both Cline sources read plain files, so they have no Node requirement.

“Not detected” here means capture only, not MCP. Registering Jolli’s MCP server just writes a config file, so it does not need to read the session database and does not check your Node version - it only checks whether the agent is installed. So on an older runtime one of these five can be missing from jolli status while its Jolli tools work normally in the chat. That combination is expected: the agent is wired up for questions about your memories, and only the automatic capture of its sessions is waiting on a newer Node.

Auto-linked references

When a session mentions an issue, page, thread, or meeting in a supported tool, Memory can attach it to the Memory as a reference. There are two kinds of reference:

With-context references - the title, a link, and a few key fields are captured, and the reference is included as context when Memory generates the summary. Ten trackers produce with-context references:

• Linear
• Jira
• GitHub
• Notion
• Confluence
• Asana
• monday.com
• Slack
• Zoom (meetings)
• Zoom (docs)

Tracking-only references - a lightweight bookmark: the link and a short label are recorded so you can see what the session consulted, but the fetched content is not saved and the reference is not fed into the summary. A near-empty body on one of these is expected, not a bug. Five sources are tracking-only today:

• Context7 (library-documentation lookups) - records the library, a Context7 link, and your query only. Context7’s full documentation response is intentionally not saved, and the reference is not used as a source when generating memory summaries. Each Context7 reference carries a short note on its page saying so, so a near-empty body is expected, not a bug.
• Jolli Memory itself - when a session consults your own memory through the recall, search, or get_decision_timeline tools, that lookup is recorded as a reference with the queries you asked. It is the one reference with no link to follow, because there is no external page to open. Keeping it out of the summary is deliberate: recalling memory must never feed back into the memory being written.
• Vercel (deployments), Figma (design files), and Sentry (issues) - the link and a short label are recorded, and the fetched detail is not saved. These three are matched on the Claude Code path only, so Claude Code and Kimi Code CLI reach them and Codex does not. They also do not appear in the IntelliJ tool window, which recognizes a fixed set of source types.

Coverage by agent: references are extracted from Claude Code, Codex CLI, and Kimi Code CLI sessions - other agents still produce full Memories but no auto-linked references yet. Claude Code covers all ten with-context trackers, plus all five tracking-only sources. Codex covers nine of the ten with-context trackers - everything except Zoom docs - plus Context7 and Jolli Memory. Kimi Code names its tool calls the same way Claude Code does, so it is matched on the same path and reaches the same trackers, for anything you use through that tracker’s MCP server. Kimi transcripts carry no pasted Slack links, so a Slack reference there takes its URL from the slack.workspaceUrl setting.

Captured skill usage

Alongside the conversation itself, Memory records which skills a session entered, so a commit shows the skills that produced it and roughly what they cost. Both ways of entering a skill are counted: the agent choosing it, and you typing it as a slash command.

Four sources report skill usage:

The other sources report nothing here, and that is not a gap waiting to be filled: Gemini CLI, Antigravity, Cline, and Devin have no on-disk notion of a skill, so there is nothing for Memory to find. Cursor ships skills but leaves no record of running one, so it reports nothing either.

You see the result in two places, and they render the same table:

• In your Memory Bank folder, as a skills--<commit>.md file per commit.
• In the VS Code sidebar, for the work you have not committed yet.

The table lists each skill, how many times it was entered, and its token totals split into input, output, and cached. Two things are deliberate: an inferred row carries a footnote marker, and a skill whose cost could not be attributed shows a dash rather than a zero, because zero would read as a measurement. An estimated figure is prefixed with ~.

There is no separate setting for this. Skill usage follows the same per-agent toggle as everything else that source captures, so turning the source off turns this off with it.

Session-start briefing vs Recall

An automatic session-start briefing (the “Auto briefing” column above) is a short [Jolli Memory — <branch>] block prepended to a new session in a repo with Memories, on feature branches only.

Three agents get one, and what it takes differs:

• Claude Code gets it from the CLI alone, with nothing extra to install.
• Cursor and Codex get it once you install the Jolli plugin for that agent. Without the plugin, neither does.

Every other agent pulls context on demand with jolli recall or the recall skill. For the briefing’s size, the branches it skips, when to run an explicit Recall instead, and the per-agent setup, see Recall vs Search and Jolli Memory in Your AI Agent.

Turning a source on or off

Every source is enabled automatically when its agent is detected. To turn one off, set its toggle to false.

From the CLI:

jolli configure --set cursorEnabled=false    # stop capturing Cursor
jolli configure --set codexEnabled=true      # capture Codex again
jolli configure --set kimiEnabled=false      # stop capturing Kimi Code
jolli configure --remove cursorEnabled       # back to auto-detect
jolli configure --list-keys                  # list every config key

In VS Code (or a fork such as Cursor or Windsurf) or IntelliJ, use the Settings panel. All surfaces read the same config file at ~/.jolli/jollimemory/config.json, so a change in one place applies everywhere.

Toggle defaults:

• claudeEnabled defaults to on. The rest default to auto-detect, which means on whenever the agent is detected.
• Three toggles each cover two sources: copilotEnabled (GitHub Copilot CLI + Chat), cursorEnabled (the Composer IDE + the cursor-agent CLI), and clineEnabled (the Cline VS Code extension + the Cline CLI).

My tool isn’t captured

Work through these in order:

1. Run jolli status. It lists each detected agent, whether it is enabled, and how many recent sessions it found. If your agent is missing entirely, it was not detected.
2. Check your Node version for the SQLite-backed sources, marked Yes in the “Node 22.13+?” column above. These need Node 22.13+. On an older runtime they show as not detected.
3. Restart hook-based agents. Claude Code and Gemini CLI must be started after jolli enable. If you started one first, restart it.
4. Mind the freshness window. Memory only considers sessions updated within the last 48 hours. An older session is not picked up.
5. Confirm the detection path. The agent must have written its session to the expected location listed in the table above. A non-standard install or data directory can hide it. For OpenCode, set XDG_DATA_HOME.

If a commit was made with no supported agent running, there is no transcript to read, and Memory falls back to a diff-only summary.

Related

• Getting Started with Jolli Memory - install, sign in, and your first Memory.
• Recall vs Search - how the Claude Code briefing and manual Recall reach your next session.
• Reference - the per-agent config toggles and other keys.