How Cross-Meeting Memory Works: The Architecture Behind Multi-Session AI State Machines

Why single-session LLM prompts fail on continuous engineering workflows. A deep architectural breakdown of temporal graphs, entity resolution, and deterministic state transitions.

Sarah Chen, Head of AI & Systems Architecture at Rapto AI
Sarah Chen

Head of AI & Systems Architecture

•11 min read•Updated Aug 29, 2026
High-speed optical network cables representing multi-session AI memory architecture
High-speed optical network cables representing multi-session AI memory architecture

The Stateless LLM Bottleneck

Standard LLM applications treat every meeting as an isolated island. You upload a 45-minute audio transcript, send a prompt like "Extract all action items", and receive an ephemeral JSON array.

The fundamental flaw? Software engineering is an ongoing, asynchronous graph, not a series of disconnected episodes.

When an engineer says in Monday's standup:

*"I'm waiting on Mark's pull request before I can deploy the telemetry pipeline."*

And on Thursday says:

*"It's merged and live in US-East."*

A single-session LLM sees two unrelated fragments. It cannot know that the Thursday statement fulfills the dependency stated on Monday.

text
Single-Session AI:
[Call 1] ──► Extract Items ──► Dump Text (Context forgotten)
[Call 2] ──► Extract Items ──► Dump Text (No link to Call 1)

Rapto Cross-Meeting Memory:
[Call 1] ──► Commitment Node #104 [PENDING] ──┐
                                              ├──► State Transition: [FULFILLED]
[Call 2] ──► "It's merged" ──► Graph Resolver ─┘

Architecture: The Temporal Entity Graph (TEG)

Rapto solves this with a Temporal Entity Graph (TEG). Every meeting contributes nodes and edges to an evolving project state:

mermaid
graph TD
  User((Engineer: Alice)) -->|Pledged in Mtg #1| C1[Commitment #104: Optimize DB queries]
  C1 -->|Target Date| D[2026-08-20]
  C1 -->|Linked Tool| L[Linear Issue: ENG-492]
  User -->|Spoke in Mtg #2| C2[Utterance: 'Database queries latency down 40%']
  C2 -.->|Resolved via Graph Matching| C1
  • Entity Extraction: Identifies technical terms, branch names, PR numbers, and user handles.
  • Temporal Edge Binding: Connects promises to relative and absolute timestamps.
  • State Engine: Transitions states based on multi-source events (speech, Git webhooks, Jira status).

  • Pronoun & Ambiguity Resolution in Developer Dialogue

    Developers rarely speak in clean formal specifications. They say "I pushed it", "We scrapped that approach", or "Sarah took over the migration".

    To resolve these ambiguities accurately, Rapto executes a three-stage filter:

  • Temporal Horizon Pruning: Restricts candidate commitments to the speaker's active backlog within the relevant 14-day window.
  • Vector + Symbolic Hybrid Match: Combines semantic embeddings of the commit context with exact symbol matches (e.g. ticket numbers like AUTH-102, endpoint names like /v1/checkout).
  • Bayesian Confidence Gate: If confidence exceeds 0.88, the status updates automatically. If between 0.65 and 0.88, a subtle Slack confirmation is prompted.

  • State Machine Implementation & Graph Nodes

    Here is the deterministic TypeScript schema powering the commitment node resolver:

    typescript
    interface TemporalCommitmentNode {
      id: string;
      tenantId: string;
      creatorUserId: string;
      assigneeUserId: string;
      verbalStatement: string;
      normalizedAction: string;
      confidence: number;
      originMeetingId: string;
      originTimestamp: string;
      targetDeadline: string | null;
      status: "PENDING" | "IN_PROGRESS" | "BLOCKED" | "FULFILLED" | "SUPERSEDED";
      externalIntegrations: {
        linearIssueId?: string;
        jiraTicketKey?: string;
        githubPrNumber?: number;
      };
      resolutionProof?: {
        resolvedMeetingId?: string;
        resolvedUtterance?: string;
        gitEventSha?: string;
        timestamp: string;
      };
    }
    Pro Tip

    By decoupling deterministic graph state from statistical LLM reasoning, the system prevents hallucinations while maintaining deep context across months of collaboration.


    Zero-Data Retention Tenant Sharding

    Enterprise security demands that cross-meeting memory does not compromise confidentiality:

  • No Foundation Model Training: Transcripts and graph states are never routed to public training loops.
  • Tenant-Level Cryptographic Isolation: Graph nodes are encrypted at rest using envelope encryption (AES-256-GCM) with customer-managed keys (AWS KMS / GCP Cloud KMS).
  • Configurable TTLs: Squads can configure graph retention policies (e.g., auto-purge meeting transcripts after 30 days while retaining anonymized fulfillment metrics).
  • Frequently Asked Questions

    The resolution pipeline searches the speaker's open commitment subgraph for unresolved items within that temporal window, evaluates semantic similarity against the ticket or bug discussed on Tuesday, and establishes a probabilistic match above 0.88 confidence.

    Share:
    Sarah Chen, Head of AI & Systems Architecture at Rapto AI
    Sarah ChenHead of AI & Systems Architecture

    Ex-DeepMind Research, MIT EECS, 12+ Distributed AI Patents

    Sarah leads AI systems architecture at Rapto, specializing in large language model reasoning, real-time audio pipeline synthesis, and deterministic state extraction from multi-party conversations. Former Senior Staff Research Engineer at DeepMind and MIT EECS alum.

    Related Deep-Dives & Guides

    Ready to keep every meeting promise?

    Onboard your entire team in under 5 minutes. Flat team rates, zero per-seat anxiety.

    No credit card required · 5 free meetings/mo · Works with Zoom, Meet & Teams