Last Updated: 4/30/2026

Jolli Memory

When you work with an AI coding agent, the reasoning behind every decision lives in the conversation: why you picked this approach, what alternatives you rejected, what dead ends you hit. The commit message captures none of it. A week later, you can’t remember why; neither can the teammate who asks.

Jolli Memory captures that context automatically. On every commit, a background worker reads your AI session transcript and your git diff, then attaches a structured summary to the commit: Why, Decisions, Implementation. The commit returns instantly; the summary appears shortly after in your editor.

What you get

• A sidebar (in VS Code or IntelliJ) with panels for status, stored Memories, plans and notes, pending changes, and commits.
• Structured commit summaries stored with your repo, not in any cloud. Your git history stays normal.
• AI Commit - generates commit messages from the staged diff.
• Squash - merges summaries when it merges commits.
• Create PR - writes a pull-request description from your accumulated Memories (uses the local gh CLI).
• Recall - feeds branch context into your next AI session so you don’t start from zero.
• Push to Jolli - optional, when you want to share your Memory.

Memory works with four agents: Claude Code, Codex CLI, Gemini CLI, and OpenCode. You can use more than one in the same repo; each commit is summarized with the agent that produced it named in the Memory.

Privacy

Private by default. Transcripts stay on your machine. Summaries stay with your repo. Nothing leaves your machine until you explicitly push a Memory to share. No telemetry, no analytics, Apache 2.0.

Install

Three install paths. Pick the one that matches your editor and skip the rest.

VS Code

Requires VS Code 1.80+. For OpenCode session discovery, you’ll need VS Code 1.99+ (bundled with Node 22.5+).

Open the Extensions view, search for Jolli Memory, click Install. Or:

code --install-extension jolli.jollimemory-vscode

VS Code Forks

Compatible with VSCodium, Cursor, Windsurf, and other VS Code forks available on Open VSX.

Open the Extensions view, search for Jolli Memory, click Install. Or use your fork’s CLI:

codium --install-extension jolli.jollimemory-vscode  # VSCodium
cursor --install-extension jolli.jollimemory-vscode  # Cursor
# etc.

Sign In limitation: OAuth Sign In with Jolli currently works only with VS Code, VS Code Insiders, Cursor, Windsurf, Antigravity, Kiro, and VSCodium. For other VS Code forks, you’ll need to use BYOK (Anthropic API Key) or sign in via CLI instead.

IntelliJ

Compatible with IntelliJ IDEA 2024.3+ (build 243) through 2026.2. PyCharm, WebStorm, RustRover, GoLand, and other IDEA-based IDEs work too.

Settings → Plugins → Marketplace → search Jolli Memory → Install. Restart the IDE when prompted.

CLI

Headless. Works in any editor (Vim, Emacs) or in CI. Requires Node 22.5 or later.

npm install -g @jolli.ai/cli
jolli --version

If you use more than one editor, install the CLI globally plus each editor’s plugin. They share the same configuration at ~/.jolli/jollimemory/config.json.

Sign in

Memory needs a credential to generate summaries. Two options.

You can switch or add the other credential later.

For non-interactive setups (CI, scripts), create a personal Jolli API key at Settings → Jolli Memory → Create Key. Copy it immediately - the format is sk-jol-... and it appears once. Set with jolli configure --set jolliApiKey=<key>. Revoke from the same page; revoked keys are dead immediately.

Enable in your repo

Open a git repository.

• VS Code - click the Jolli Memory icon in the Activity Bar → Enable Jolli Memory in the Status panel. Reload the window so hooks take effect.
• IntelliJ - open the Jolli Memory tool window → Enable → restart the IDE.
• CLI - jolli enable from the repo root; verify with jolli status.

Enabling installs git hooks (to trigger summary generation after each commit) and agent hooks for Claude Code and Gemini CLI (to capture session transcripts). Codex CLI and OpenCode don’t need hooks - Memory discovers Codex sessions by scanning the filesystem and OpenCode sessions by reading the local OpenCode SQLite database ~/.local/share/opencode/opencode.db).

Make your first commit

Open your AI agent and code normally. Ask it to make a small, real change. Conversational pairing is the point - the more reasoning lives in the transcript, the better the Memory.

In Claude Code, a [Jolli Memory — <branch>] block prepends your first message. That’s Memory’s session-start briefing (auto-injected for Claude Code only; other agents pull it manually via Recall).

Stage and commit as usual:

git add <your files>
git commit -m "Fix tile generation when grid snaps are fractional"

The commit returns immediately. In the background, Memory reads your transcript and the diff, generates a summary, and stores it with the commit.

See your first Memory

The commit appears in the Commits panel with a Memory attached. Click the eye icon to open the Memory view, three collapsible sections:

• Why - what problem the commit solved and why now.
• Decisions - trade-offs, alternatives rejected, non-obvious choices. The part that disappears without Memory.
• Implementation - what was built and how.

Each section is editable inline. “From the CLI: jolli view for a list, jolli view --commit 1 for the latest commit’s Memory, or jolli view --commit <hash> for any commit-hash prefix. HEAD, branch names, and tags are not accepted.

The sidebar at a glance

Memory’s sidebar has five panels. Same in VS Code and IntelliJ.

AI Commit

Turn a staged diff into a commit message. Sends only the diff (not your conversation history), so it’s cheap and fast. The full Memory still generates separately after the commit lands.

In the Changes panel, check the files and click the sparkle icon. Memory stages the selection, generates a message, and opens a dialog to review and edit before committing.

Use AI Commit for routine commits. Write the message manually when the commit captures a decision worth recording in the message itself.

Squash

Collapse a range of contiguous commits into one and merge their Memories. Useful for cleaning up WIP history before merging to main.

In the Commits panel, check the commits to combine (checking one auto-selects everything above it) and click Squash. Memory uses git reset --soft, generates a merged message, and the new commit carries reasoning from every original. Nothing is lost.

Skip Squash when intermediate commits are worth preserving as landmark bisect points.

Create PR

Turn your branch’s accumulated Memories into a pull-request description.

Prerequisites: gh CLI installed and authenticated, at least one commit with a Memory, branch pushed to GitHub.

Open the Memory view for any commit on the branch. In the Pull Request section, click Create PR. Memory generates a description with Summary, Motivation, Decisions, and links to attached plans.

If the PR already exists, the button becomes Update PR. Memory refreshes the managed block (delimited by the marker pair <!-- jollimemory-summary-start --> and <!-- jollimemory-summary-end -->) without touching content you added outside it.

A typical day

You start a session with your AI agent. If you’re using Claude Code, the session-start briefing kicks in automatically. Using Codex CLI, Gemini CLI or OpenCode? Just pull context with Recall when you need it.

As you work, you make changes and commit, AI Commit handles the message for you. Keep going like this for as long as the task takes.

When you’re ready to wrap up the branch, take a look at your commit history. Too many WIP commits cluttering things up? Squash them down into something cleaner.

Finally, push your branch and open the Memory for the lead commit. Click Create PR, review the description it generates, and submit.

Recall

Every Memory captures why a past commit happened. Recall feeds that history back into your next AI session.

Automatic, Claude Code only. When you start a Claude Code session in a repo with Memories, a ~300–500-token [Jolli Memory — <branch>] block prepends the conversation: branch name, recent Memories’ summaries, key decisions, and pinned plans. Compact enough not to eat your context budget; long enough to give the agent the gist.

Codex CLI, Gemini CLI and OpenCode don’t get the auto briefing - pull it manually instead.

Explicit, any agent. Inside Claude Code, run /jolli-recall (optionally /jolli-recall <branch>) for a deeper pull. From the CLI:

jolli recall

Useful flags: --full (full content, not summaries), --depth <n>, --budget <tokens> (default 30,000), --include-transcripts, --output <path>. See Reference for the full set.

Use explicit Recall when the branch is more than a few days old, when you’re picking up someone else’s work, or when the 300–500-token briefing isn’t enough. The session-start briefing itself starts proactively suggesting /jolli-recall after 3 days of inactivity on a branch.

Push to Jolli

When a commit’s reasoning would help a teammate, Push to Jolli posts the structured summary (Why / Decisions / Implementation) to a dedicated Jolli Memory Space in your workspace. Your raw transcript stays on your machine.

Note: you must be logged in to Jolli (or have entered a Jolli API key) in order to push to Jolli.

Open the Memory view for the commit and click Push to Jolli. After a successful push, the Push to Jolli button changes to Update on Jolli to indicate the Memory has been published.

To share a multi-commit story, Squash first, then push the merged commit.

What gets sent:

• The structured summary (Why / Decisions / Implementation), formatted as the Memory Article’s title and content.
• The commit hash and branch name.
• The plugin version (used for the server-side version gate).
• Every plan and every note attached to the commit. Each lands as a separate Article in the Plans & Notes subfolder of the Memory Space — including any free-form text typed into a note.

What doesn’t get sent: AI session transcripts, the raw diff content, plans or notes that aren’t attached to this commit.

Pushed Memories are attributed to your account. Only you (or an admin via the web UI) can delete them. Push specifically requires a Jolli API Key - sign-in saves one automatically, but you can also paste one in the Settings panel without going through sign-in. BYOK-only setups (Anthropic API key only, no Jolli account) cannot push.

To remove a pushed Memory, delete the Article from the Memory Space in the web UI. The local Memory is untouched.

Next steps

• Reference - config keys, commands, and recovery paths.
• Jolli Spaces - once you’ve pushed a Memory, the team-side story for what to do with it.