Beyond Memory: A Templated Substrate for Collaborative Knowledge Work with LLM Agents

Teaser: A July 2026 paper from Microsoft Research proposes a templated substrate for heterogeneous LLM agents to collaborate on knowledge work — research synthesis, literature reviews, and technical documentation — through structured shared representations rather than shared memory. This article examines the architecture, the template model, and why this approach outperforms both monolithic agents and free-form multi-agent chat.

Introduction

The dominant paradigm for multi-agent AI systems is shared memory — agents write to and read from a common store, coordinating implicitly through the data they leave behind. But a July 2026 paper from Microsoft Research, "Beyond Memory: A Templated Substrate for Heterogeneous Collaborative Knowledge Work with LLM Agents," argues that shared memory is insufficient for knowledge-intensive collaboration.

The problem: knowledge work — research synthesis, literature reviews, technical documentation, competitive analysis — requires not just storing facts, but maintaining epistemic structure: which claims are supported by which sources, how conclusions were derived, what uncertainties remain, and how different agents' contributions relate to each other. Shared memory (vector stores, key-value caches, even graph databases) captures the data but loses the reasoning structure.

The paper proposes a templated substrate — a shared structured representation that encodes the epistemology of the knowledge work being performed. Agents collaborate by filling in, extending, and linking templates, rather than by reading and writing free-form memory.

This article unpacks the architecture, the template model, and why this approach may define the next generation of knowledge-intensive AI systems.

The Problem: Memory Is Not Enough

Consider three AI agents collaborating on a literature review about GraphRAG:

• Agent A (researcher) searches arxiv, identifies 15 relevant papers
• Agent B (analyst) reads papers, extracts findings
• Agent C (writer) synthesises findings into a structured review

With a shared memory architecture, each agent writes to a common store:

// Agent A writes:
{ "type": "paper", "title": "GraphRAG: Unlocking LLM Discovery on Narrative Private Data", "arxiv_id": "2404.16130" }

// Agent B writes:
{ "type": "finding", "paper": "GraphRAG", "claim": "Graph-based index improves answer comprehensiveness by 27%", "confidence": 0.92 }

// Agent C reads both and tries to write a review

The problems are subtle but critical:

1. Missing provenance — Agent C cannot verify that Agent B's finding is correctly attributed to the right paper version
2. No uncertainty propagation — Agent B's confidence score is static; Agent C has no way to know which parts of the synthesis are contested
3. No contradiction resolution — If Agent B finds conflicting claims across papers, there's no structure to represent the contradiction
4. Lost reasoning chains — When the final review is written, the chain of reasoning from raw papers → extracted findings → synthesis → conclusions is invisible

The Templated Substrate Architecture

The templated substrate replaces free-form memory with a typed template graph:

┌──────────────────────────────────────────────────────────┐
│                    Templated Substrate                    │
│                                                           │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐   │
│  │  Template     │  │  Template    │  │  Template    │   │
│  │  Registry     │  │  Instances   │  │  Links       │   │
│  │               │  │              │  │              │   │
│  │ • PaperReview│  │ • pr-001     │  │ • pr-001 ──▶ │   │
│  │ • Claim      │  │ • claim-042  │  │   ext-015    │   │
│  │ • Evidence   │  │ • ev-007     │  │ • claim-042 ─▶│   │
│  │ • Synthesis  │  │ • syn-003    │  │   ev-007     │   │
│  └──────────────┘  └──────────────┘  └──────────────┘   │
│                                                           │
│  ┌──────────────────────────────────────────────────┐    │
│  │  Agents interact via TEMPLATE OPERATIONS          │    │
│  │  • INSTANTIATE(template_id) → new instance        │    │
│  │  • EXTEND(instance_id, slot, value)               │    │
│  │  • LINK(source_id, target_id, rel_type)           │    │
│  │  • RESOLVE(contradiction_id, resolution)          │    │
│  └──────────────────────────────────────────────────┘    │
└──────────────────────────────────────────────────────────┘

Template Definitions

Templates are typed schemas that define the structure of a knowledge artifact:

template: PaperReview
version: 1.2
slots:
  - name: paper_metadata
    type: PaperMetadata
    required: true
    cardinality: 1
  - name: extracted_claims
    type: Claim
    required: false
    cardinality: 0..*
  - name: quality_assessment
    type: QualityScore
    required: true
    cardinality: 1
  - name: relation_to_query
    type: RelevanceStatement
    required: true
    cardinality: 1

constraints:
  - "quality_assessment must be completed before synthesis can reference this review"
  - "each extracted_claim must link to one or more Evidence instances"

operations:
  - agent_type: extractor
    fills: [paper_metadata, extracted_claims]
  - agent_type: evaluator
    fills: [quality_assessment]
  - agent_type: synthesperson
    reads: [extracted_claims, quality_assessment]
    fills: [relation_to_query]

Template Instances as a Graph

When agents work on a literature review, they create a densely linked graph of template instances:

graph TD
    Q[Query: GraphRAG effectiveness] -->|frames| SR[ScopingReview: sr-001]
    SR -->|includes| PR1[PaperReview: pr-arxiv-2404.16130]
    SR -->|includes| PR2[PaperReview: pr-arxiv-2501.05407]
    SR -->|includes| PR3[PaperReview: pr-arxiv-2503.12345]

    PR1 -->|produces| C1[Claim: graph-index improves comprehensiveness 27%]
    PR2 -->|produces| C2[Claim: hierarchical communities outperform flat clustering]
    PR3 -->|produces| C3[Claim: GraphRAG cost is 2-5× flat RAG]

    C1 -->|evidenced_by| E1[Evidence: Table 3, GraphRAG paper]
    C2 -->|evidenced_by| E2[Evidence: Figure 4, CommunityRAG paper]
    C3 -->|evidenced_by| E3[Evidence: Section 5.2, CostRAG paper]

    C1 -->|supports| Syn[Synthesis: syn-001]
    C2 -->|supports| Syn
    C3 -->|contradicts| C4[Claim: GraphRAG cost is comparable to flat RAG]
    C4 -->|evidenced_by| E4[Evidence: Internal benchmark, unresolved]

    Syn -->|concludes| A[Answer: GraphRAG improves quality at 2-5× cost]
    C4 -->|pending_resolution| R[Resolvable: requires cost normalisation]

    classDef query fill:#4C78A8,stroke:#2c4e6e,color:#fff
    classDef review fill:#54A24B,stroke:#3a7a35,color:#fff
    classDef claim fill:#F58518,stroke:#b35a0e,color:#fff
    classDef evidence fill:#E45756,stroke:#b33d3d,color:#fff
    classDef synthesis fill:#72B7B2,stroke:#4e8b87,color:#fff
    class Q query
    class SR,PR1,PR2,PR3 review
    class C1,C2,C3,C4 claim
    class E1,E2,E3,E4 evidence
    class Syn,R synthesis

Each template instance is a node; each slot fill or cross-reference is an edge. The result is a knowledge graph of the collaboration itself — not just the domain facts, but how those facts were elicited, evaluated, and assembled.

How Agents Collaborate via the Substrate

Agents interact with the substrate through a small set of typed operations, not through free-form memory reads and writes.

Operation 1: INSTANTIATE

An agent creates a new template instance when it identifies a new unit of knowledge work:

# Agent A (scoping agent) creates a scoping review template
scoping = substrate.instantiate(
    template_id="ScopingReview",
    slots={
        "research_question": "How effective is GraphRAG compared to flat RAG?",
        "search_strategy": "arxiv: 2024-2026, query: 'GraphRAG' AND 'evaluation'",
        "inclusion_criteria": ["empirical evaluation", "standard RAG baseline"]
    },
    agent_id="scoping-agent-v2"
)

Operation 2: EXTEND

An agent fills one or more slots in an existing template instance. Extensions are versioned and attributable:

# Agent B (extractor) fills the extracted_claims slot on a PaperReview
substrate.extend(
    instance_id="pr-arxiv-2404.16130",
    slot="extracted_claims",
    value=[
        Claim(
            text="GraphRAG improves answer comprehensiveness by 27% over baseline RAG",
            confidence=0.92,
            location="Table 3, row 4",
            extraction_method="direct_quote"
        ),
        Claim(
            text="Community hierarchy depth correlates with answer quality (r=0.74)",
            confidence=0.85,
            location="Figure 6",
            extraction_method="inferred_from_plot"
        )
    ],
    agent_id="extractor-agent-v1",
    parent_version="pr-arxiv-2404.16130@v1"  # Previous version this extends
)

Operation 3: LINK

Agents create typed links between template instances to represent epistemic relationships:

Relation Type	Meaning	Example
supports	Instance A provides evidence for Instance B	Claim → Synthesis
contradicts	Instance A conflicts with Instance B	Claim → Claim
evidenced_by	Instance A is supported by Instance B	Claim → Evidence
frames	Instance A sets context for Instance B	Query → ScopingReview
includes	Instance A contains Instance B	ScopingReview → PaperReview
pending_resolution	Conflict requires human resolution	Claim → Resolvable

Operation 4: RESOLVE

When two claims contradict, agents can propose resolutions:

substrate.resolve(
    contradiction_id="contr-003",
    resolution=Resolution(
        type="contextualised",
        statement="GraphRAG costs 2-5× flat RAG for query-time compute, but the gap narrows when accounting for reduced hallucination-related rework",
        resolved_by="synthesis-agent-v2",
        preserves=["C1", "C3"],  # These claims are preserved in the resolution
        supersedes=["C4"]        # This claim is refined
    )
)

Evaluation Results

The paper evaluated the templated substrate against three baselines on a literature review task (synthesise 20 papers → produce a structured analysis):

Metric	Shared Memory (Vector)	Multi-Agent Chat	Monolithic Agent	Templated Substrate
Claim attribution accuracy	67%	71%	82%	96%
Contradiction detection rate	31%	52%	44%	78%
Source traceability	2.1 hops	3.4 hops	1.0 hops	∞ (fully traced)
Human review time (min)	45	38	52	18
Synthesis completeness	58%	64%	71%	88%

The largest gains are in claim attribution accuracy (+29% over shared memory) and human review time (60% faster). The template structure makes the reasoning chain transparent — a human reviewer can inspect the claim→evidence→synthesis chain directly rather than reading raw chat logs.

Implications for Knowledge Work

The templated substrate has implications beyond the paper's immediate scope:

For research teams — The substrate encodes not just findings but how they were reached. A literature review produced through this process is auditable: every claim points back to the extraction event, the source paper, and the specific evidence slice.

For technical documentation — Template types for API documentation, architecture decisions, and integration guides would enforce consistency across documents produced by different agents, while maintaining cross-reference links.

For competitive analysis — Templates for "Competitor Profile," "Feature Comparison," and "Market Positioning" would ensure that analyses from different agents are structurally comparable and composable into a unified view.

Limitations

Limitation	Details
Template authoring burden	Templates must be designed upfront. The paper used manually crafted templates; automatic template induction is future work.
Agent specialisation	The system assumes agents are typed (extractor, evaluator, synthesizer). General-purpose agents require capability declarations to determine which template operations they can perform.
Scalability of link graph	With 100+ template instances, the link graph becomes dense. The paper used Neo4j as the backing store; query performance depends on index design.
Evaluation scope	The experiments focused on literature review tasks. Generalisation to other knowledge work (code review, design doc writing, incident analysis) is unvalidated.

Conclusion

The "Beyond Memory" paper makes a compelling case that the next frontier in multi-agent AI is not better memory but better epistemic structure. By replacing free-form shared memory with a templated substrate that encodes how knowledge work should be structured, the system achieves higher attribution accuracy, better contradiction detection, and dramatically faster human review.

For teams building knowledge-work agents, the takeaway is practical: design the shared representation before you design the agent coordination. The templates define what good looks like, and the agents fill in the gaps.

The paper and reference implementation are available on arXiv and GitHub (July 2026).