---
title: Shared context for multi-agent workflows
description: Evaluate software-factory memory for coding-agent handoffs, source-linked lessons and reported outcomes, with a runnable evidence-handoff reference.
seo:
  title: Shared memory for a software factory and multi-agent workflows
sidebar:
  label: Shared memory for a software factory and multi-agent workflows
---

Loom is a self-hosted MCP server for multi-agent memory, with namespace-scoped tokens and
separate read and write roles. Agents share context through memory, task inboxes and
decision records within the namespaces they can access. Your agents and orchestrator run
the workflow; Loom keeps what they learn and hand over.

## What you get

- **Shared memory with provenance.** Every row records which agent wrote it, and under the
  default `auto_reinforce` policy a contradiction between two agents is flagged for review
  instead of silently overwritten. [Namespaces and sharing](/docs/features/namespaces-and-sharing) ·
  [Namespace conflict policy](/docs/features/memory/conflicts-and-refusal#namespace-conflict-policy)
- **Task inboxes.** Each agent has a durable queue with leases, retries and review rules;
  a claimed task has one owner at a time. [Tasks, decisions and policies](/docs/features/tasks-and-decisions)
- **Decisions.** What was decided in a case like this, why, and whether it worked.
  [Decisions](/docs/features/tasks-and-decisions#decisions)
- **Working memory.** Text an agent is given every time instead of finding it by
  search, separate from long-term memory. [Working memory and profiles](/docs/features/memory/working-memory-and-profiles)
- **Context packs.** `context.pack` builds the bounded bundle an agent loads at the start
  of a task. [Unified search and context packs](/docs/features/unified-search)
- **Session briefs.** The resumable state of one line of work: goal, status, decisions,
  dead ends and what is done. One agent saves it with `session.brief_save` and the next
  loads it with `session.brief_get`. [Session briefs](/docs/features/conversations-and-sessions#session-briefs)
- **Framework adapters.** The SDKs present Loom through agent frameworks' own memory
  interfaces, including [Mastra threads, messages and resource working memory](/docs/features/integrations/frameworks#mastra).
  [Agent frameworks](/docs/features/integrations/frameworks)

## Two agents sharing a research note

On one person's laptop, the [single-user quickstart](/docs/getting-started/quickstart)
lets two connected agents read the same namespace. Connect both clients with the
[connect guide](/docs/getting-started/connect-a-coding-agent); for example, use Claude
Code to collect a finding and Cursor to write from it.

1. In the first client, ask it to use `loom_memory_set` to save
   `example/research/next-step` with the value “Check the paper's evaluation dataset
   before adding it to the reading list.” Check the returned `memory_id` and find the
   row in the dashboard.
2. In the other client, ask it to use `loom_memory_get` to read that exact key. Require
   the tool response, including `found`, `value` and `agent`, before it drafts a next
   step. It should read the first client's value and identify its writer.
3. Delete the example key from the client that wrote it when finished.

The agents share a saved fact; Loom does not run them or schedule their work. For agents
on different people's machines, use an [authenticated team deployment](/docs/getting-started/quickstart#start-in-multi-user-mode),
with each person's own token granting access to the same namespace. A local single-user
run does not test those access controls.

## Memory for a software factory

When autonomous coding agents take an issue through implementation and review, Loom keeps
shared context, source-linked lessons and reported outcomes between those stages. Your
agents and orchestrator execute the work and enforce review and CI requirements.

Use an indexed repository and separate agent credentials with access to the shared
namespace. Check [shared recall and denied access](/docs/getting-started/evaluate#shared-memory-across-clients)
before relying on the deployment for team work.

1. **Recover the task.** Load relevant context with `context.pack`, keeping the issue,
   acceptance criteria and current revision with the task. With a registered tracker,
   [check prior reports and candidate changes](/docs/features/tracker/overview#from-a-bug-draft-to-candidate-prs).
   An unavailable or degraded duplicate check leaves that question unresolved.
2. **Inspect the source.** Read the current definitions, callers and affected code before
   changing it. Follow the [code intelligence walkthrough](/docs/use-cases/code-intelligence); use local
   tools for uncommitted changes the index has not seen.
3. **Keep the reason.** Save a durable lesson or decision with its evidence and the
   qualified definitions it concerns. Follow the [repository tag and namespace rules](/docs/use-cases/memory-linked-to-code#start)
   so the code-link worker can resolve it. Keep the current plan in working memory.
4. **Hand off the evidence.** Pass the issue, revision, lesson keys, completed checks and
   open questions to the next agent. The [planner and worker example](https://github.com/ClickHouse/loom/tree/main/sdk/python/examples#multi_agent_handoffpy)
   shows fenced task ownership, separate credentials and result provenance.
5. **Review against current code.** Inspect the diff and the lesson's link state. A
   `changed` link calls for checking the claim; it does not establish that the claim is
   false. Follow [check a lesson after a code edit](/docs/use-cases/memory-linked-to-code#check-a-lesson-after-a-code-edit).
   Treat the agent's reported completion separately from review and CI results.
6. **Record the outcome.** Correct an outdated claim at the same memory key. Record which
   memories each run relied on and close the run once, following the [run and procedure reporting rules](/docs/use-cases/autonomous-agents#check-one-agent-task).
   Keep failed checks and unresolved questions with the handoff.

The [Python software-factory reference](https://github.com/ClickHouse/loom/tree/main/sdk/python/examples#software_factory_memorypy)
implements this evidence handoff with separate implementation and review credentials.
Start with its indexed public repository and review-inbox setup. It compares the served
function body and reports operation receipts; it does not generate a patch, decide whether
a lesson is true or run code review. The example documents cleanup limits and supplies
no captured live output.

### Choosing memory for a software factory

The best memory tool for a software factory depends on the evidence each stage needs.
An issue, a conversation transcript, a reusable lesson and a test result serve different
purposes. Keep the source revision and check results with the handoff so the next agent
can distinguish a stored claim from a verified result.

| Question                           | Evidence to collect                                                                                                                                               |
| ---------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Can another agent use the handoff? | Read the saved result with the review identity; check the writer, issue, revision and unresolved work.                                                            |
| Does the lesson still apply?       | Inspect the current definition and its link state. Record the reviewer's judgment rather than treating a changed hash as an invalid lesson.                       |
| Can unrelated agents read it?      | Run a separate denied-access check with a token outside the shared namespace. A different agent name alone is not an access boundary.                             |
| Did memory help the task?          | Compare task outcomes under the same model, repository revision, tasks and review criteria. Include failed checks and the cost of storing and retrieving context. |

The reference above exercises an evidence handoff; it is not a measured software-factory
benchmark. A reported completion is not a passing test, an accepted patch or proof that
memory helped. Your orchestrator remains responsible for enforcing those gates.

For a single coding assistant, start with [coding-agent memory](/docs/use-cases/agent-memory#choosing-a-memory-tool-for-coding-agents)
and its cross-session check. For architecture trade-offs, read [Choosing memory for a software factory](https://github.com/ClickHouse/loom/discussions/939).
Use the [code-linked lesson example](/docs/use-cases/memory-linked-to-code#check-a-lesson-after-a-code-edit)
to evaluate source freshness separately from recall.

## Start

[Integrate Loom into an agent](/docs/guides/agent-integration) covers the identity each
agent sends and what to write; [tokens and grants](/docs/guides/tokens-and-grants) gives
each agent its own token.

Run the [planner and worker example](https://github.com/ClickHouse/loom/tree/main/sdk/python/examples#multi_agent_handoffpy)
to follow a task from posting through fenced completion and read its result with
provenance. It uses separate tokens and deletes the result memory after the handoff.

Some ops on this page are marked experimental on the [status page](/docs/reference/status).
