Memory linked to code for coding agents
Loom links coding agents' memories to the functions, classes and files they name, follows
them through refactors, and flags a memory when its code changes. By default, search leaves
out a memory whose code is all gone unless a person pinned, locked or verified it, and every
read that serves a lesson says when its code changed or is gone. It runs over MCP, HTTP and
the SDKs on the repositories a self-hosted Loom indexes (the
code index, LOOM_CODE_INGEST_ENABLED=true), and the
memory_code_links worker that keeps the links is on by default.
What you get
- Lessons attached to the code they are about. A memory tagged
repo:<id>(the Claude Code and Codex plugins tag what their hooks capture) or written in the repository's code namespace is linked to each definition (function, class or other symbol) it names in backticks, or anywhere in its text asA::bor a call (a.b(),name()), that resolves to exactly one place (an unqualified name needs four or more characters); to definitions in the files it lists that it names by a bare camelCase or snake_case word; and to each file it lists that holds none of them. A qualified name not on trunk yet links if it merges withinLOOM_MEMORY_CODE_LINKS_PENDING_DAYS(14 days). Memories linked to code - Links that follow refactors. On every indexed commit, each link reads
fresh,moved,changed(naming the commit that changed it),unresolvedormissing. A link records the definition's tokens, so whitespace, comments and most formatter changes leave itfresh. Link states - Stale memories handled the way you choose. The namespace's
code_change_policydecides:retire_removed(the default) leaves a memory whose code is all gone out of search and flags changed code;flagonly flags;revisealso leaves gone-code memories out, and has the model check a changed one's claim against the old and new code: one that still holds is re-anchored, and a contradicted one gets a suggested correction. A memory a person pinned, locked or verified is never left out. Under every policy, search usually ranks a memory whose code changed below the next three results instead of hiding it; a held memory and a row found by name keep their place. Loom never rewrites the memory itself. Policies - Lessons wherever the agent reads code.
code.symbolreturns the memories linked to a definition aslessons;code.search,code.callers,code.callees,code.impact,code.outlineand a task'scode.context_packattach the lessons for the files they return; each lesson carries its link state. The Claude Code and Codex hooks show a file's memories (memory.for_file) before an agent edits it, and the Cline hooks when it reads or edits one.code.symbol· Claude Code plugin · Codex plugin · Cline hooks (experimental) - Shared with the team. Lessons are read from the repository's code namespace and the namespaces the call names (over MCP, the caller's own by default), so a lesson saved in the repository's code namespace reaches every agent that may read that namespace (a token narrowed to its own user or session reads no lessons). Memories linked to code
- Branches read their own code. On another branch, a lesson is checked against that
branch's own definition, so a release branch that still has the old text reads
fresh(on a host withLOOM_GIT_HISTORY=none, which has no git mirror, a lesson carries trunk's state). Memories linked to code - Documents beside the code. Documents from a source registered on the repository's code
namespace (its trunk's) carry the repository's tag, so searches over the repository read
them with its code (the sync worker needs
LOOM_KNOWLEDGE_SOURCE_SYNC_ENABLED). Document sources - A review list.
namespace.validatelists the memories whose code changed, was not found again or is gone, and the dashboard shows each memory's links and their state.

Start
Quickstart boots Loom, and
adding repositories turns the code index on for a
repository. Connect your coding agent with its plugin or over MCP
(connect a coding agent). Save a lesson that
names a definition of four or more characters in backticks or as a call (`name()`), or
a qualified one such as `Reader.run`. The Claude Code and Codex plugins tag what their
hooks capture with repo:<id>, and the session primer names the id
(how it is derived). A lesson the
agent saves itself with loom_memory_set links when it carries that tag
(tags: ["repo:<id>"]) or is written in the repository's code namespace; any client can do
either. Over HTTP (or agent.call in the Python SDK), a lesson saved in your own namespace
is read only when the call names that namespace in lesson_namespaces. Each link pass links
writes at least 60 seconds old and passes run every 60 seconds, so once trunk is indexed,
code.symbol on that definition returns the lesson under lessons within about two
minutes.
Check a lesson after a code edit
On the repository's indexed trunk, save a lesson such as `fetch_page()` retries on code 115
with the repository tag or in its code namespace, as above. Use a name that resolves to
one definition. After the link pass, read that definition with code.symbol and look for
the saved memory under lessons. When included, it carries code_state: "fresh".
Include the memory's namespace in lesson_namespaces when the call needs it.
Change an expression in the function's body, such as return url to return url.strip(),
and commit it on trunk. After the index and link worker process that commit, read the
definition again in the same trunk namespace. Under the default policy, a returned
lesson carries code_state: "changed"; changed_since names the indexed
commit. This marks changed code, not a judgment that the lesson is false. Read the
current body before applying it. Uncommitted editor changes do not trigger this check.
Symbol cards cap the lessons they return and can omit the saved lesson. If it is absent,
use memory.get to inspect that memory's code links and their states.
The existing test_memories_follow_their_code
integration regression
checks these states across commits. It also checks a pure move (moved), removed code
(missing) and a release branch whose unchanged definition still reads fresh.
The packaged MCP smoke
saves a lesson, verifies fresh, commits a body edit and waits for the indexing and link
workers to return changed with that exact commit. The
quickstart harness
restarts the Loom service, checks the link again and deletes the test memory.
CI runs these checks
on amd64 and arm64 with authentication off, a local embedder and a fake model provider.
These checks verify code-link state; authenticated clients, answer quality and agent
tool selection are not tested.
For removal, held-memory exceptions and model-backed revision, see the link policies.
Some ops on this page are marked experimental on the status page.