Skip to Content
Jolli MemoryGetting Started with Jolli Memory

Last Updated: 7/13/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.

What you get

  • Structured commit summaries - Why, Decisions, Implementation - attached to each commit and stored with your repo, not in any cloud. Your git history stays normal.
  • Recall - feeds a branch’s past reasoning into your next AI session so you don’t start from zero.
  • Search - find a past decision across every branch.
  • Share in Jolli - optional, publish a Memory to your team.
  • Runs headless from the CLI in any terminal, editor, or CI. An optional editor extension (VS Code, Cursor, Windsurf, IntelliJ) adds a visual sidebar and in-editor actions - see Editor extensions, below.

Keep coding with your AI the way you already do. Memory works in the background: you do not change your workflow, and reviewing or curating what gets captured is optional.

Memory captures from six AI coding assistants across seven sources: Claude Code, Codex CLI, Gemini CLI, OpenCode, Cursor (Composer), and GitHub Copilot (both the Copilot CLI and VS Code Copilot Chat). Use more than one in the same repo and each Memory names the assistant that produced it. For exactly how each is captured, see Supported AI Assistants and Capture.

Privacy

Private and local-first. Your summaries and transcripts are stored with your repo, not in any cloud. Generating a summary does send your transcript and diff to the LLM (Anthropic directly, or the Jolli proxy, which holds them only for that request and never stores them); nothing is published to anyone else until you explicitly Share a Memory. Licensed under Apache 2.0.

Jolli Memory does collect content-free usage telemetry, on by default. It never sends your code, file paths, commit messages, diffs, transcripts, Memory content, or repo or branch names, and the payload carries no account identifier (though when you are signed in, events upload under your Jolli key, so they can be attributed to your account on our end). Turn it off with jolli telemetry off, or by setting DO_NOT_TRACK to any non-empty value other than 0. For the exact fields it sends and every opt-out path, see Troubleshooting and FAQ.

Install the CLI

The CLI is the primary way to use Jolli Memory - it works in any terminal, any editor, and in CI. It requires Node 22.5 or later - on an older Node, upgrade first (e.g. nvm install 22). (Prefer clicking to the terminal? You can use an editor extension instead - see Editor extensions, below.)

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

That gives you the jolli command. Next: sign in, then enable it in a repo. (To try a command without a global install, npx @jolli.ai/cli <command> works too; for day-to-day use - where the git hooks call jolli - install it globally as above.)

Or have your AI agent install it

If you already work in a terminal agent like Claude Code or Codex, you can just ask it to set Jolli up for you. Paste this in:

Install the Jolli Memory CLI: run npm install -g @jolli.ai/cli, then jolli auth login to sign me in, then jolli enable in this repository and show me jolli status.

The agent runs the commands and reports back. Then pick up at “Make your first commit” below.

Sign in

Jolli Memory needs a credential to generate summaries. Two options:

  • Sign in with Jolli (recommended) - OAuth into Jolli and use Jolli’s LLM proxy. Choose this if you might Share to your team later.

    jolli auth login

  • BYOK (bring your own key) - Memory calls Anthropic directly with your key. Choose this if you already pay Anthropic, or want to evaluate before creating a Jolli account.

    jolli configure --set apiKey=sk-ant-api03-...

You can switch or add the other credential later. For CI or scripts, create a personal Jolli API key at Settings → Jolli Memory → Create Key (format sk-jol-..., shown once) and set it with jolli configure --set jolliApiKey=<key>.

Enable in your repo

From the root of a git repository:

jolli enable
jolli status

enable installs the git hooks that trigger summaries, plus agent hooks for Claude Code and Gemini CLI; the other five assistants are discovered automatically and need no hook. status confirms your hooks, credential, and detected assistants. A fresh repo shows Stored memories: 0 until your first commit generates one - that’s expected, not a misconfiguration.

If a hook-based assistant (Claude Code or Gemini CLI) was already open when you enabled, restart it so the hooks attach - this is the most common reason a first Memory doesn’t appear. (Discovery-based assistants - Codex, Cursor, OpenCode, Copilot - need no restart.) Run jolli status to confirm your assistant was detected; if it is missing, it may need a newer Node or editor build. See Supported AI Assistants and Capture for the per-assistant details.

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. Commit without an AI session and you still get a Memory, just a thinner, diff-only one.

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 - usually within about 10 to 20 seconds.

Already have history? Run jolli backfill to create Memories for commits made before you enabled Jolli (Claude Code transcripts only; defaults to the last 20 commits). The editor extension also offers this as a prompt when you enable a repo that already has commits.

See your first Memory

From the CLI:

jolli view              # list recent Memories
jolli view --commit 1   # open the latest commit's Memory

If jolli view shows nothing right after committing, the summary is still generating - wait a few seconds and run it again. --commit takes a numeric index (1 is the latest) or a commit-hash prefix; HEAD, branch names, and tags are not recognized. Each Memory leads with a Quick recap, then a card per topic with labeled callouts:

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

In the editor extension, the same Memory opens in a visual Memory view with editable callouts (see Editor extensions).

Recall

Recall feeds a branch’s past reasoning back into your next AI session. In Claude Code it is automatic: a compact [Jolli Memory — <branch>] briefing prepends the conversation at session start. Every other assistant pulls it on demand with jolli recall (or the /jolli-recall skill). When a repo is enabled, Memory also registers an MCP server so an MCP-aware assistant can recall and search your history conversationally.

For the automatic-vs-explicit details, flags, and how Recall differs from Search, see Recall and Search and Connect Memory to Your AI Assistant (MCP).

Share in Jolli

When a commit’s reasoning would help a teammate, publish it to a dedicated Jolli Memory Space your team can read. Sharing needs a Jolli API Key (sign-in saves one), so BYOK-only setups cannot share.

From the CLI, find your Space and push - the first push binds the repo automatically, so there’s no separate bind step:

jolli spaces                          # list the Spaces you can publish to
jolli push --space <space-id-or-slug> # binds on first use, then publishes this branch's Memories

It sends the summary, commit metadata, changed-file paths, any extracted references (Linear, Jira, GitHub, Notion, Slack, Zoom), your repo’s remote URL, and any attached plans and notes; it never sends your transcripts or the raw diff. To share a multi-commit story, squash first, then push.

Auto-sync on push: once a repo is bound to a Space, a git push also syncs that branch’s Memories to the Space in the background when you’re signed in - so you often don’t need to run jolli push by hand. Turn it off with jolli configure --set syncOnPush=false.

In the editor extension, the Memory view has a Push to Jolli button (Share in Jolli in IntelliJ) for the same thing, plus a separate Share button for link-based sharing (anyone in your account, anyone with the link, or only people you name). Heads up: when you are signed in, clicking Create PR in the extension also publishes the branch’s Memories to your team in the same step.

Once pushed, the Memories appear in that Space in the Jolli web app - that’s where your team reads and builds on them. Shared Memories are attributed to you and are removed by deleting the Article from the Space in the web UI; your local copy is untouched. See Jolli Spaces for the team-side story.

Editor extensions (optional)

Prefer a visual sidebar to the terminal? Install the extension for your editor. It is entirely optional - the CLI does everything headless - but it adds a sidebar and in-editor actions on top of the same stored Memories.

Install:

  • VS Code (1.80+) - Extensions view, search Jolli Memory, Install. Or code --install-extension jolli.jollimemory-vscode.
  • Cursor and Windsurf (and other VS Code forks) - same flow via Open VSX, e.g. cursor --install-extension jolli.jollimemory-vscode. OAuth Sign In works in VS Code, Cursor, and Windsurf; if it doesn’t complete on your fork, use BYOK or jolli auth login.
  • IntelliJ (2024.3+ and other JetBrains IDEs) - Settings → Plugins → Marketplace, search Jolli Memory, Install, then restart the IDE.

Enable it by clicking the Jolli Memory icon in the VS Code Activity Bar (or opening the tool window in IntelliJ); hooks install automatically, then reload the window (VS Code) or restart the IDE (IntelliJ) so they take effect. Sign-in and BYOK also have buttons here: Status overlay → Sign In to Jolli, or Settings → AI Summary → Anthropic API Key (in IntelliJ, Settings → Tools → Jolli Memory).

The sidebar leads with a segmented Current Branch / Memory Bank switch and a repo / branch breadcrumb, plus Settings (gear) and Status (a pulse icon opening a full-pane overlay):

  • Current Branch - three blocks: Pinned, Working Memory (what is composing for your next commit, with the Commit Memory button), and Committed Memories.
  • Memory Bank - a cross-branch, cross-repo view of every stored Memory on disk, with search and a Tree / Timeline toggle. See Memory Bank and Sync.
  • Status overlay - enable/disable, sign-in state, active AI sessions, the summary provider your next commit will use, and any missing-credential warning.

In-editor actions:

  • AI Commit - generates a commit message from the staged diff (the Commit Memory button; sends only the diff, not your conversation). The full Memory still generates separately after the commit lands.
  • Squash - collapses a range of contiguous commits into one and has an LLM merge their Memories, for cleaning up WIP history before merging to main. Nothing is lost.
  • Create PR - drafts a pull-request description from the branch’s Memories (needs the gh CLI, a commit with a Memory, and the branch pushed). When signed in, it also publishes the Memories to your team.

Next steps

Welcome to JolliSupported AI Assistants and Capture