Knowledge Graph

The Knowledge Graph is a map of everything a project’s conversation index holds, and a place to ask it questions. Open it from the brain icon in the title bar or with Ctrl+Shift+A / Cmd+Shift+A, and close it the same way. Quick Find answers “where is the word I typed?”. The Knowledge Graph answers “what have we done about this, and what did it cost?”, across every task the board recorded.

Every past conversation is a point on the map, placed by what it is about, so work on the same subject clusters together. Type a question and an agent you picked answers it from the related tasks, their facts, and, if you turn it on, the project’s code. The map narrows to the tasks the answer names.

Turning it on

The Knowledge Graph is off until you switch it on in Settings > Knowledge Graph. The switch downloads a small embedding model (the one Conversation memory describes, IBM’s Granite embedding English R2 by default) and then runs it offline. That local model finds work by meaning and draws the map. Turning the Knowledge Graph on also turns conversation indexing on, if it was off.

The Knowledge Graph does not run on an Intel Mac, which Kangentic builds for since v0.46.0. Its local model runs on onnxruntime, and onnxruntime ships no Intel macOS build, so there the Settings card and the map’s place both read Unavailable and say the local model does not run on that machine, and the model is never downloaded. Kangentic treats the feature as off there whatever the config says. Conversation indexing and keyword search still work.

Asking questions needs one more choice: the Agent and Model that answer, set in the same card. Nothing picks them for you, because the agent that runs your tasks and the agent that reads their history are different choices. Until both are set, pressing Enter in the question box opens Settings at the Agent row and keeps your question typed. Come back and press Enter again.

The first time a project opens the graph, Kangentic reads every embedding in the index to place the points. On a large project that takes a few minutes, runs in the background, and happens once. After that the map updates in about a second as new conversations are indexed. While it builds, a card in the middle of the screen shows each step (reading the conversations, placing them, naming the regions) beside the same source lines the Index card lists.

Until the local model has embedded anything, the graph shows an Off card with an Open Settings button instead of a map. Without embeddings there is no meaningful “near”, and a map drawn without one would claim a meaning it does not have. Switching the Knowledge Graph off later keeps the map it already drew.

The map

Each indexed conversation is a point in 3D space, placed by the meaning of its text. Links join each conversation to its nearest neighbors. Regions are named automatically from the task titles of the conversations inside them, and with Task summaries on, from each task’s summary too. A region then reads as what its work touched rather than how its titles happened to be worded. As summaries are written the regions are renamed in place, and no conversation moves.

The two kinds of distance are not equally precise, and the graph says so. Links are exact, computed in the embedding’s full dimensionality. Position is approximate, because squeezing hundreds of dimensions into three loses information. “Nearby” is a strong hint. When you want certainty, follow the links.

The map is drawn on the GPU. On a machine that cannot provide a 3D drawing context, such as a blocklisted driver or some remote sessions, the graph says so, and Ask and the Index figures keep working.

Moving around

Drag to orbit, right-drag to pan, and scroll to zoom. Click the map, then fly with the keyboard:

Keys	Move
`W` / `S`	Forward and back
`A` / `D`	Slide left and right
`Q` / `E`	Rise and drop

You can fly into a cluster and out the other side. The toolbar at the bottom of the map holds Reset view, which frames the whole map again so you can always get un-lost, and Controls, which lists these keys. With no chat open, Reset view also clears the selected conversation.

Every change to what the map shows moves the camera by flying, never by a cut: narrowing a filter, landing an answer, or adding a project. Opening the graph, switching the open project, and resizing the window reframe at once.

Points and the detail panel

Hover a point for its title and size. Click it for a detail panel that shows the conversation’s task summary, when one is written, and its Closest conversations. Those are its strongest links, in order. They carry no percentage, because the embeddings sit in a similarity band so narrow that every row would read “99%”.

The panel has two actions:

Open conversation, or a double-click on the point, opens the full transcript in a movable window over the map, the same conversation viewer Quick Find opens.
Explore from here re-scopes the map to that conversation and everything it links to. A breadcrumb at the top of the map takes you back.

The left panel

The panel holds four cards, and each one collapses.

Filter sets what is on the map, and it is also the scope of any question you ask:

Projects. The graph opens on the project you have open. Pick any other indexed projects, or All, and each draws as its own labeled island. None goes back to the open project alone. A project the graph has never shown builds its map the first time you pick it, which takes about a minute on a large project.
Time: Any, 30 days, or 90 days.
Status: Any, Done (a task in the Done column, or archived), or Open (every other task on the board).

A choice that cannot narrow this index is disabled, and its tooltip says why.

Regions cuts the map into more or fewer regions with Detail: Coarse, Balanced (the default), or Fine. All three are computed with the map, so switching is instant. No score can pick this for you, since every way of scoring a clustering prefers the fewest regions on a cloud this continuous. On a small index every setting gives the same regions, and the control hides itself. Below it, the region list shows each region’s color and size with a switch per region, plus All and None. Past a dozen regions the list gains a Find a region box.

Display sets what the points encode with Color by:

Color by	What it shows
Topic	The region each conversation belongs to
Recency	Warm is recent, cool is old: where your attention has moved, and which areas have gone quiet
Status	Green is Done, amber is still open on the board, gray has no task. Offered only when the smaller group is large enough to see; on a lopsided board use the Status filter instead
Length	How much transcript the conversation holds, on a ramp from deep indigo to warm yellow
Duration	How long it ran in wall time, on the same ramp
Cost	What it cost to run, on the same ramp

Length, duration, and cost are three different questions, not three readings of one: a long conversation is not reliably a slow one, and a slow one is not reliably an expensive one. Show turns the region labels and the similarity links on and off.

Index opens beside the panel. It lists the same sources as the Settings card, without the switches, and then the figures only the map has: Links, Transcript gone (conversations whose agent transcript file was deleted while their indexed text still answers queries, which on a mature project is most of them and is not a problem), Not yet indexed, Failed to index, and Size on disk. Open Settings goes to Settings > Knowledge Graph.

Asking questions

Type a question in the box and press Enter. “What was the most expensive task?”, “why did we drop the sphere fit?”, and “which tasks touched the relay?” all work. The question moves into a chat on the right. Follow-ups go in the chat’s own box, and the X in its header ends the chat. The chat is not saved, and it also ends when you switch projects. Each question costs one agent call, and the glyph at the end of the box names the agent before you press Enter.

What the agent sees

Before the agent starts, Kangentic searches every indexed conversation and every task’s own record (its title, labels, description, and summary) for the question. That search runs locally in under a second and rolls the matches up per task. The map lights the related set at once, brighter where a task matches more strongly, and the chat reads “Reading 14 related tasks” while the agent works.

The agent is then handed:

the related tasks, with their strongest passages, facts, and summaries,
a table of every task in scope, including tasks with no indexed conversation, with each one’s cost, duration, tokens, sessions, files and lines changed, pull request and whether it merged, last activity, region, and the agent and model that ran it, with totals computed before the agent sees them,
with Source code on, the passages of code that read closest to the question, and
the chat so far.

The table settles factual questions exactly, so “what was the most expensive task?” is a lookup, not a guess. Code goes to the agent only when it reads close enough to the question, so a question about the board gets no code.

An agent that can use a tool also gets exactly one: kangentic_search, scoped to the projects the question was asked across, with four searches per question. Each search shows as a step in the chat, and the conversations it found get a white ring on the map. Nothing else loads. The agent gets no other Kangentic tool, none of your other MCP servers, and not the project’s own instructions, so it cannot create, move, or delete anything.

The reply

The reply is a few sentences that name tasks by their ticket, drawn as small #561 marks. Under it, a row per task the reply is about, five at first and then Show all. A row or a mark opens that task’s most relevant conversation over the map, scrolled to the passage the answer used, and that window’s Open task closes the graph and opens the task on the board. A task with no indexed conversation opens on the board directly.

When the answer lands, the map narrows to the tasks it names and the camera flies in. A follow-up that narrows the answer narrows the map with it, and clicking an earlier turn brings its tasks back. An answer that names no task, such as “nothing here covers that”, leaves the plain map. Asked something neither the table nor the conversations cover, the agent says so rather than guessing. If the agent fails, its reason is shown as it came, with Try again.

With several projects in the Filter, the box reads “Ask across 3 projects”. Every project’s tasks go into one table and one search, and because ticket numbers repeat between projects, the reply names another project’s task with its project, like Mobile #88.

Choosing the agent

Agent, Model, and Effort in the Knowledge Graph card are one choice for the whole app. The same agent and model also write the task summaries.

Agent. Every agent with a headless read-only mode can answer. Warp has none, so it is not offered.
Model. Required wherever the agent’s answer run takes one. Reading the index is lighter work than writing code, so a cheaper model can be enough. Measured on Claude, the smallest model answered the test questions as reliably as a mid-size one, a second faster and at about a twentieth of the cost. It also invented more details in task summaries, and the one model does both jobs.
Effort. Shown when the agent’s CLI reports effort levels, and it starts at low, which answers fastest. low is the place to start. A higher level is worth a try when a question that counts or compares across many tasks comes back wrong. Effort applies to answers only; summaries always run at the agent’s recommended level, where a higher one changed nothing.

The Model list has the same Latest and Specific versions layout as the task and column pickers (see Creating tasks).

What it reads

The Index card in Settings > Knowledge Graph lists what the index searches, one line per source:

Source	What it holds	Switch
Conversations	Each session’s structured transcript, the points on the map	Always on while the index is on
Tasks	Each task’s and backlog item’s own text	Always on while the index is on
Commits	The commits on the project’s default branch, each tied to the task whose conversation wrote it	Always on while the index is on
Task summaries	A sentence or two per Done task, written by the agent	On by default
Source code	The default branch’s files	On by default

A running source shows its share done and the time left over a progress track (“22%, 3 min left”). A finished one shows its count with a check. The figures cover every indexed project, the same projects the graph’s All map draws. Task summaries and Source code wait, spending nothing, until the Knowledge Graph has an agent, and say so on their line (“Needs the Knowledge Graph”, “Needs an agent”). Their switches still work while they wait, so you can turn one off before choosing the agent that would start it.

Task summaries

Once the Knowledge Graph has an agent and a model, the agent writes a sentence or two about each Done task: what it set out to do and what it ended up doing. It writes from the task’s title and description, the files its sessions changed, the commits it landed on the default branch, and how its last sessions ended. A summary is searched with its task and handed to the answering agent beside it, so a question finds a task by what it did, not only by what its title says.

Summaries are written in the background, ten tasks to a call, three calls at a time, and a task that reaches Done gets one on the next pass. Every project is asked once each launch, a minute in, whether or not you open it. Behind with nothing writing, the line shows how many are written and how many the agent passed over (“670 of 673, 3 skipped”); those are asked about again on the next launch. A failed call reads A call failed in yellow, with when it will retry. When a call fails and no other call in the pass was answered, every project’s summaries wait until that retry, since one agent writes them all. A call that fails beside one that answered holds back only its own project.

Switching summaries off stops new calls and keeps the summaries already written, so they go on helping search. A new model applies to new and changed tasks, and Rebuild rewrites the rest.

Source code

With Source code on, the index reads the project’s default branch as committed: origin/main (or whatever the project’s base branch is), else the local branch of that name, else the remote’s own default, else the branch you have checked out. It reads source files and docs, and skips tests, fixtures, data files, lock files, build output, and anything over 256 KB. Each file is split into passages at its top-level declarations and embedded in the background by the local model.

The first pass over a large repository is slow, and several times slower on a CPU than on a GPU (see Model acceleration). After that, when the branch moves, only the files whose content changed are read again. While it is off, its line shows how many files it would read. Switching it off clears the open project’s code index at once, and another project’s the next time you open it. Switching the Knowledge Graph off, or clearing its agent, keeps the code index as it is, so turning it back on costs nothing.

Rebuilding the index

Rebuild the index, at the bottom of the Index card, reads every source again in every project without deleting anything: the open project now, every other one the next time you open it. You need it only if search misses something you know is there, or after changing the agent or model, when it also rewrites the summaries written the old way. When a rebuild would rewrite summaries, it asks first and says how many and about how many calls. Changing Search quality re-indexes in the background on its own.

Prior work on a task

The map is somewhere you go. Prior work is the same recall coming to you. Open a task, and if the index holds earlier conversations near it, a line under the description reads “3 earlier conversations about this”. Expand it to see them, and click one to open its transcript.

The task’s own title and description are the query, so there is nothing to type. The task’s own history is left out, since that is already one click away in the header. When there is no earlier work near a task, nothing is shown. See Task detail window.

Quick Find hands off

Quick Find matches words only, and it is instant because it starts no embedding model. Its last row, Ask the Knowledge Graph: “what you typed”, hands the query to the graph, which answers by meaning. A typed question usually has no keyword matches, and then that row is selected, so Enter asks it.

For agents

Your agents read what the Knowledge Graph knows over the MCP server:

kangentic_search recalls past conversations by meaning (the default) and finds the commits a query matches, each with the task it came from. It also ranks tasks by a topic (groupBy: "task") or by how like one task they are (relatedToTask).
kangentic_find_task and kangentic_get_current_task carry a finished task’s summary, the commits linked to it, and the files its sessions changed.

Settings

All of these are in Settings > Knowledge Graph, apply to every project, and are stored under knowledgeGraph.*.

Setting	Card	Default	Description
Knowledge Graph	Knowledge Graph	Off	Turn on the local model and the agent rows. Turning it on also turns the index on
Search quality	Knowledge Graph	Best (Granite English R2)	Which local model finds by meaning: Best or Light (bge small). Changing it re-indexes in the background
Model acceleration	Knowledge Graph	Auto	Where the local model runs: Auto, GPU, or CPU
Agent	Knowledge Graph	None	Which agent answers questions and writes task summaries
Model	Knowledge Graph	None	The model that agent uses for both
Effort	Knowledge Graph	`low` where the agent has a recommended level	How hard the agent thinks when it answers
Index	Index	On	Index conversations, tasks, and commits. Off disables all conversation search
Task summaries	Index	On	Let the agent write a summary for each Done task
Source code	Index	On	Index the default branch’s code for answers

The status row under Search quality reads Downloading over a progress track, then Local model with the model’s name, size, and where it runs, or Download failed in red. A License line under it links the model’s license.

These settings were the Memory tab’s through v0.43.2. The first launch of v0.44.0 moves them under the new name, and a key you already set under the new name wins. See the Configuration reference for every key.

Privacy

The index, the local model, the map, and the search that picks the related tasks all run on your machine. Ask and task summaries are the exception: they send text to the agent you chose, the same way any task you give that agent does. A question sends the related tasks’ passages, facts, and summaries, the task table, and, with Source code on, the closest code passages. A summary call sends each task’s title, description, changed files, and commits. Which provider that reaches depends on the agent and model you picked. See Privacy and analytics.

Pop out

Like the Agent Monitor and Usage Stats, the graph detaches into its own OS window from the pop-out control in its header.