Skip to Content
Jolli MemoryGetting Started with Jolli Memory

Last Updated: 8/20/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 ten AI coding agents across thirteen sources: Claude Code, Codex CLI, Gemini CLI, OpenCode, Cursor (the Composer IDE and the cursor-agent CLI), GitHub Copilot (both the Copilot CLI and VS Code Copilot Chat), Cline (the VS Code extension and the CLI), Devin, Antigravity, and Kimi Code CLI. Use more than one in the same repo and each Memory names the agent that produced it. For exactly how each is captured, see Supported AI Agents 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

This page follows the CLI, which works in any terminal, any editor, and in CI. Jolli Memory also ships as a plugin for Claude Code, Cursor and Codex, and as an extension for VS Code and JetBrains. For every option and how to choose, see Install Jolli Memory.

macOS, Linux and WSL

curl -fsSL https://jolli.ai/install.sh | sh

Windows PowerShell

irm https://jolli.ai/install.ps1 | iex

The script installs the CLI, installs Node if you need it, then hands off to the guided setup, so you finish with Memory already enabled in your repo. That guided setup is the bare jolli command: it does the work of jolli auth login, jolli enable, and jolli status in one pass, and on a repo that already has commits it offers to capture your recent history right then. Run jolli on its own any time to re-enter it, or jolli --help to see every command.

Jolli Memory needs Node 22.13 or later. If the script finishes and there is still no jolli command, that is almost always the Node version, and it fails quietly. See Install Jolli Memory for why, or Troubleshooting and FAQ to fix it.

The guided run ends by opening the local dashboard and serving it until you press Ctrl+C, so Ctrl+C there loses nothing.

Prefer to run each step by hand, or script it for CI? The manual path is Sign in then Enable in your repo, below.

Sign in

Jolli Memory needs a way to generate summaries. Three options:

Installed one of the agent plugins? This is already handled. Each plugin records its own agent as the tool that writes your summaries, so Claude Code, Cursor and Codex all generate Memories with no credential. Skip ahead to Make your first commit, and sign in only when you want to share memories to a Space.

  • 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-...

  • Use a local agent CLI (no key) - if you already have one of these installed and signed in, Memory can drive it to generate summaries through its own subscription, with no Anthropic key and no Jolli account.

    jolli configure --set aiProvider=local-agent --set localAgentTool=claude-code

    Five agents are supported. Use the id in the left column as the localAgentTool value:

    IdAgentHow to sign in
    claude-codeClaude CodeRun claude once and sign in to your subscription.
    codexCodexRun codex login to sign in with your ChatGPT plan.
    cursor-agentCursorRun cursor-agent login to sign in to Cursor.
    opencodeOpenCodeRun opencode auth login to connect a provider.
    kimiKimi CodeRun kimi login to sign in to your Moonshot account.

    Note that Cursor’s id is cursor-agent, not cursor. If the agent’s binary is not on your PATH, add jolli configure --set localAgentPath=/path/to/binary. This powers summary generation only; Sharing to a team Space still needs a Jolli API key.

You can switch or add another later. For CI or scripts you want a personal Jolli API key instead - see Jolli Memory in CI and Automation.

Enable in your repo

jolli enable is the single command that sets Jolli Memory up in a repository - it installs everything and then helps you configure a credential.

Install your AI agents first. enable wires up whichever agents it finds on your machine at the moment you run it, and it does not repeat that on its own. An agent you install later stays unregistered until you run jolli enable again.

Run it from the root of a git repo:

jolli enable
jolli status

enable does three things in one pass:

  1. Installs the git hooks that drive Memory - post-commit, post-rewrite, prepare-commit-msg, post-merge, and pre-push.
  2. Wires up your coding agents - agent hooks for Claude Code and Gemini CLI, plus the MCP server and Memory’s skills, registered into every agent it detects. The other eleven sources are discovered automatically and need no hook.
  3. Sets up a credential - in an interactive terminal (skip with -y), enable helps you choose how summaries get generated. If exactly one local agent CLI is already installed and working, it is selected automatically, with no key and no menu. Otherwise you get the four choices above. So you do not have to run jolli auth login first - enable can do the sign-in for you.

status then confirms your hooks, credential, and detected agents. A fresh repo shows Stored memories: 0 until your first commit generates one - that’s expected, not a misconfiguration.

Handy flags: -y skips the interactive prompts (for CI or scripts); --integrations-only sets up the MCP server and skills without installing any git or agent hooks (for hosts that manage their own, such as the IntelliJ plugin); --cwd <dir> targets a specific repo.

Now restart your AI agent. This is the most common reason a first Memory doesn’t appear. Which agents need it, and why every agent needs one restart before Memory’s MCP tools show up, is covered in Supported AI Agents and Capture.

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? Running jolli offers a backfill automatically on a repo that already has commits, and the editor extension prompts for the same on enable. To run it yourself, jolli backfill creates Memories for commits made before you enabled Jolli (Claude Code transcripts only; commits with no attributable transcript get a diff-only summary). It defaults to the last 20 commits - use --last <n> for more, or --all for every commit missing a Memory.

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, and in Cursor or Codex with the Jolli plugin installed, it is automatic: a compact [Jolli Memory — <branch>] briefing prepends the conversation at session start. Every other agent pulls it on demand with jolli recall, or with the recall skill for that agent. When a repo is enabled, Memory also registers an MCP server so an MCP-aware agent can recall and search your history conversationally.

For the automatic-vs-explicit details, flags, and how Recall differs from Search, see Recall vs Search and Use Your Memory from Any AI Agent (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, Confluence, Asana, monday.com, Slack, Zoom, Vercel, Figma, Sentry, and Context7 library lookups), 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.

In the web app, the top-level repo folders in a Memory (Vault) space now show a View knowledge graph button that opens an interactive, pan-and-zoom view of that repo’s knowledge graph.

Editor extensions (optional)

Prefer a visual sidebar to the terminal? There is an extension for VS Code and its forks, and a plugin for JetBrains IDEs. Both are optional - the CLI does everything headless - and both add a sidebar on top of the same stored Memories. For how to install each one, see Install Jolli Memory.

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). OAuth Sign In works in VS Code, Cursor, and Windsurf; if it doesn’t complete on your fork, use BYOK or jolli auth login.

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.

For the in-editor actions - AI Commit, Squash, Create PR and the rest - and their CLI equivalents, see Reference. Heads up: when you are signed in, clicking Create PR also publishes the branch’s Memories to your team in the same step.

Next steps

Welcome to JolliSupported AI Agents and Capture