Last Updated: 9/2/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).
• Node 22.13 or later for the jolli CLI, and for the sources marked Yes in the “Node 22.13+?” column below, which read a local SQLite database.
• Hook-based agents (Claude Code, Gemini CLI, and Hermes Agent on macOS and Linux) must be restarted after enabling. When you set Jolli up with the CLI, one restart is also what brings the MCP tools in. The agent plugins differ, and the plugin page has the per-host detail.

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 fourteen sources across eleven 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. It also does not read Hermes Agent sessions yet: every other source in the table above is captured, but Hermes work done alongside a JetBrains IDE needs the CLI installed to be picked up.

The two capture models

Hook-based: Claude Code, Gemini CLI, and Hermes Agent

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.

These agents 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 one 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.

Hermes Agent’s is an on_session_end hook, written into ~/.hermes/config.yaml. Two things are specific to it:

• The hook is installed on macOS and Linux only. On Windows, Memory registers its MCP server but no hook, so Hermes sessions there are found by the discovery model instead, at commit time.
• Every Hermes profile is set up, not just the default one. hermes profile gives you separate Hermes instances under ~/.hermes/profiles/<name>, each with its own config and its own session database, so Memory writes to all of them. Setting up only the default would look like it worked while the profile you actually use recorded nothing.

Hermes asks before it will run a hook a tool has added. Memory adds its own entry to Hermes’ allowlist when it sets the hook up, so you are not prompted for this one.

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

Why 22.13 and not 22.5. 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 cannot pass one: the VS Code extension host and the git hooks. So 22.13 is the real floor for the sources marked Yes in the “Node 22.13+?” column above. The install script checks the major version only, so it accepts any Node 22 and reports success; npm’s engines field is what refuses afterwards.

• 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, those sources are reported as not detected rather than as an error: they simply will not appear in jolli status. Sources that read plain files have no Node requirement.

“Not detected” here means capture only, not MCP. Registering Jolli’s MCP server only writes a config file, so it checks whether the agent is installed rather than what your Node version is. On an older runtime one of these six can therefore be missing from jolli status while its Jolli tools work normally in the chat: the agent is wired up for questions about your memories, and only automatic capture 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. Each Context7 reference carries a short note on its page saying so.
• 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.

Coverage by agent: references are extracted from Claude Code, Codex CLI, Kimi Code CLI, and Hermes Agent sessions - other agents still produce full Memories but no auto-linked references yet. Hermes is read a different way from the other three, out of its SQLite store rather than a transcript file, but what you get out of it is the same. 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, which agent entered it, how many times, 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.

Which agent did the work

From CLI 0.99.14, Memory records which AI tool each conversation, commit and skill came from, so you can tell your Claude Code work from your Codex work after the fact. Both dashboards use it: the local one breaks tool and skill usage down by agent, and references and memories carry their source’s own badge.

The recorded value is one name from a fixed list, never free text, and it is left out rather than guessed when the tool cannot be determined. A blank means “not measured”, not “the CLI”.

Two details are worth knowing if a figure looks thinner than you expect:

• Kimi Code and Devin are identified at commit time only. Neither leaves anything in the environment that Jolli can read while a session is running, so work in them is attributed when the commit lands rather than as it happens.
• A shared session server does not guess. When several tools share one Memory server for a checkout, attribution comes from each tool’s own connection rather than from the environment the server started in, because that environment belongs to whichever tool happened to connect first.

Older memories carry no agent at all, and nothing fills it in retroactively.

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.