Conversation Memory

Conversation Memory turns every past agent conversation in a project into a searchable knowledge base. As your agents work, Kangentic builds a local, per-project index of what was said, so you (and your agents) can answer “have we solved this before?” without scrolling through old sessions. It runs entirely on-device with no API key.

What Gets Indexed

Kangentic indexes the structured transcript of each session - the user turns, assistant replies, thinking blocks, and tool-call summaries - and deliberately never indexes the raw terminal scrollback, which for TUI agents is mostly cursor and redraw noise. Indexing is automatic and incremental:

• A session is indexed when it finishes or suspends.
• An in-progress conversation is re-indexed at each turn boundary, so it becomes searchable within a second or two.
• Older history is backfilled in small sweeps when you open a project, so a large history amortizes instead of blocking.

Indexing is on by default and can be turned off in Settings > Memory; when off, no indexing runs and nothing is searchable.

Keyword and Semantic Search

Search has two layers:

• Keyword search (on by default) is fast full-text matching over the indexed turns.
• Semantic search (opt-in) adds a small local embedding model that matches by meaning rather than literal words, so a query finds relevant conversations even when the wording differs.

When both are on, Kangentic runs a hybrid search that fuses the two rankings, and a conversation that matches both ways ranks highest. Every failure path (no model yet, extension unavailable, slow embedding) degrades transparently to keyword-only and never blocks your search. A built-in relevance filter drops off-topic and gibberish semantic hits; keyword hits are always shown.

Where You Use It

Conversation Memory surfaces in three places:

• Quick Find Ctrl+Shift+F / Cmd+Shift+F shows a Conversations group alongside tasks, backlog, events, and projects. Its mode is chosen automatically from your Memory setting (Smart/hybrid when semantic search is on, keyword when it’s off). Selecting a hit opens the read-only conversation viewer scrolled to the matched turn, or routes you to the live terminal if that session is still running.
• Every task detail window has a View conversation pill (speech-bubble icon, also in the kebab menu) that opens the task’s newest session in the viewer - no search needed. The pill is muted until the task has session history.
• The kangentic_search MCP tool lets your agents recall past conversations themselves - by keyword, or by meaning with mode: "hybrid" - and drill into a cited turn with kangentic_get_transcript. See the MCP Server reference.

The Conversation Viewer

The viewer is a real workspace window, not a modal: it floats on the board layer alongside task detail windows, and you can drag, resize, snap, tile, and maximize it the same way - so a past conversation can sit next to the live terminal that is continuing the work. Open viewers are part of your workspace: they persist across project switches and app restarts.

Each turn is rendered cleanly (user prompts, assistant replies, thinking blocks, and tool-call summaries) with per-message copy buttons. The header keeps two one-tap actions:

• Open task jumps to the task the conversation belongs to, opening its detail window.
• Copy conversation as Markdown copies the whole transcript as clean Markdown.

Both are also available from the window’s kebab menu.

Search within a conversation

An always-visible search bar sits at the top of the viewer. Type to filter the transcript to matching turns, each shown with a short snippet, and step through the hits with the prev/next controls (or Enter and Shift+Enter) while a counter tracks your position. Press Ctrl+F / Cmd+F to jump straight to the search input. Clicking a result snaps instantly to that turn with no scroll animation, so finding “where did it decide to use a worktree?” in a long session is a few keystrokes rather than a manual scroll.

Where it opens

The viewer opens positioned where you want to be, not at the top:

• By default it opens at the latest message, so reopening a finished session lands on its conclusion.
• If you had scrolled up in the live terminal before opening the viewer, it opens centered on the turn matching what you were looking at, so the clean transcript picks up from the same place as the raw scrollback.

Opening a conversation from a Quick Find hit instead lands on the matched turn, briefly highlighted.

Long transcripts

The viewer is built to stay smooth on very long sessions - thousands of turns, and tens of thousands of messages. Rows are virtualized and reused as you scroll, so scrolling stays fluid no matter how long the conversation is. A custom overlay scrollbar replaces the browser default: it keeps a usable thumb size on huge transcripts, shows a position bubble while you drag, and offers a jump to latest pill to snap back to the end in one click.

Since v0.36.0 there is also a hard read bound. A transcript larger than 16 MB is parsed from its most recent 16 MB only, roughly 2,800 turns, and the viewer opens with a plain notice at the top saying how much was left out. The bound exists because parsing a whole file briefly costs about twenty times what it retains, and several such parses running at once is how the app ran out of memory on a 138 MB transcript. It applies to every agent, not just the one whose transcripts happened to be biggest.

Nothing is lost to search: the conversation index walks the whole file in windows regardless, so an omitted early turn is still findable in Quick Find and by kangentic_search.

Choosing a Model

When you enable semantic search, Kangentic downloads a small embedding model once (from Hugging Face) and then runs it offline. Pick the quality tier in Settings > Memory; all three are from the same open bge family, differing only in size, dimensions, and accuracy:

Quality	Model	Dimensions	Approx download
Balanced	bge-small	384	~34 MB
Accurate (default)	bge-base	768	~110 MB
Best accuracy	bge-large	1024	~337 MB

Embedding runs in an isolated background process so it never blocks the UI, and it is duty-cycle throttled so it paces itself and yields to any active search - even a first-run or post-model-switch backfill never pegs your CPU or GPU. A Hardware acceleration dropdown (Auto / GPU / CPU) picks where it runs - Auto and GPU prefer your GPU (DirectML on Windows, WebGPU elsewhere) and fall back to CPU. Switching models re-embeds the index in the background. A Rebuild index button re-runs the index for the current project if it ever gets stale.

Privacy

Everything is local and keyless. Only structured conversation turns are indexed (never raw terminal output), the index lives inside each project, and searching never leaves your machine. The only network access is the one-time embedding-model download when you first enable semantic search. See Privacy & Analytics.

Settings

Setting	Default	Description
Index conversations	On	Build the local search index. Off disables all conversation search
Semantic search	Off	Add the local embedding layer for meaning-based (hybrid) search
Search quality	Accurate (bge-base)	Which embedding model powers semantic search
Hardware acceleration	Auto	Whether embedding runs on GPU or CPU

See the Configuration Reference for every memory.* key.

Next steps

See also:

• Quick Find - the palette that surfaces conversation hits
• MCP Server - how agents recall conversations
• Dictation - the other on-device, keyless AI feature
• Privacy & Analytics - what stays local