Session Bridge - Structured Context Preservation for Long-Running Agent Sessions
<!-- obsidian --><h2 data-heading="Summary">Summary</h2>
<p>A pattern for <strong>preserving</strong> session context — not just compressing it — before a session resets. Session Bridge routes knowledge to permanent, structured storage rather than summarizing it into a flat file. It transforms ephemeral session state into durable, retrievable agent memory.</p>
<p><strong>The core insight: Compaction is compression. Session Bridge is preservation.</strong></p>
<p>Compaction asks "what can I forget?"<br>
Session Bridge asks "where does this knowledge <em>live</em> permanently?"</p>
<p>Built and running in production since April 2026. Open-sourced May 5, 2026 (<a href="https://github.com/monbishnoi/cal" class="external-link" target="_blank" rel="noopener nofollow" aria-label="https://github.com/monbishnoi/cal" data-tooltip-position="top">reference implementation</a>).</p>
<hr>
<h2 data-heading="Problem">Problem</h2>
<p>Context management in long-running coding agents compresses context to keep a session alive. This works well intra-session, but for long-lived agent use (daily multi-hour sessions over weeks), compression is lossy:</p>
<ul>
<li><strong>Decisions</strong> and their reasoning get flattened into summaries</li>
<li><strong>Artifacts</strong> created during a session aren't tracked with their full paths and context</li>
<li><strong>Knowledge</strong> discovered gets dumped into a flat memory file with no organization</li>
<li><strong>Cross-session continuity</strong> relies on resuming (only the immediate next session) or manual patterns</li>
</ul>
<p>Scheduled/parallel agent tasks have this more acutely: context resets between tasks by design, so recurring routines start cold every time.</p>
<p>The longer you use a coding agent, the more this matters. A single afternoon session is fine. Daily 4-hour sessions over months? Compression loses the thread.</p>
<hr>
<h2 data-heading="Proposed Pattern: Session Bridge">Proposed Pattern: Session Bridge</h2>
<p>Session Bridge has two layers:</p>
<h3 data-heading="Layer 1: Handoff (Lossless Preservation)">Layer 1: Handoff (Lossless Preservation)</h3>
<p>Before a session resets, the agent captures the full session context — not a summary, but a structured snapshot of what happened, what was decided, what was created, and what's in progress. This is written to durable storage (daily log files).</p>
<p><strong>Handoff alone is already more powerful than compression for cross-session use</strong>, because nothing is lost. The raw material is preserved for any future process to synthesize.</p>
<h3 data-heading="Layer 2: Structured Routing (Handoff++)">Layer 2: Structured Routing (Handoff++)</h3>
<p>Session Bridge extends Handoff by <strong>categorizing and routing</strong> context to the appropriate permanent locations:</p>
Category | Destination | Why
-- | -- | --
Decisions + reasoning | Project docs / decision logs | Retrievable by project, not buried in a dump
Artifacts created | Referenced with full paths | Future sessions can load specific files
Knowledge / insights | Topic-specific memory files | Organized by domain, not chronology
Active work-in-progress | Handoff summary for next session | "What does the next session need in the first 30 seconds?"
<p>This means future sessions can load <em>only what's relevant</em> rather than parsing one large blob.</p>
<h3 data-heading="Why Both Layers Matter">Why Both Layers Matter</h3>
<ul>
<li><strong>Handoff without routing</strong> = lossless but unorganized (a journal with no index)</li>
<li><strong>Routing without handoff</strong> = organized but lossy (an index to a book you threw away)</li>
<li><strong>Session Bridge (both)</strong> = lossless AND organized. Nothing lost, everything findable.</li>
</ul>
<hr>
<h2 data-heading="Four Advantages Over Compression Alone">Four Advantages Over Compression Alone</h2>
<h3 data-heading="1. Preservation, not just compression">1. Preservation, not just compression</h3>
<p><strong>Compression ≠ Preservation.</strong></p>
<ul>
<li>Compression = summarize to fit more in the window (lossy, in-session only)</li>
<li>Session Bridge = save the full context to durable storage, then reset cleanly (lossless, cross-session)</li>
</ul>
<p>Nothing is lost — it's moved to disk in a retrievable form.</p>
<h3 data-heading="2. Structured routing, not a flat dump">2. Structured routing, not a flat dump</h3>
<p>Context is categorized and written to the <em>appropriate</em> location. Future sessions load only what's relevant. Memory files don't become a growing dump with no organization principle.</p>
<h3 data-heading="3. Cross-session, not just next-session">3. Cross-session, not just next-session</h3>
<p>Resuming works for the immediately next session. Session Bridge builds persistent knowledge accessible from <em>any</em> future session — days or weeks later. The file system becomes long-term memory with structure.</p>
<h3 data-heading="4. Enables downstream memory systems">4. Enables downstream memory systems</h3>
<p>Session Bridge produces the raw corpus that makes other memory systems powerful:</p>
<pre><code>Session Bridge (preserves) → Daily Logs (accumulate) → Memory Consolidation (synthesizes)
</code></pre>
<p>Without Session Bridge, memory consolidation can only work with what's in a flat memory file. With Session Bridge, it has access to the full history — every decision, every exploration, every dead end — and can extract insights across weeks of context.</p>
<hr>
<h2 data-heading="Suggested Integration Points">Suggested Integration Points</h2>
<ul>
<li><strong>Pre-compression hook</strong> — Run Session Bridge <em>before</em> context compression fires. Bridged context persists; compressed context still works intra-session.</li>
<li><strong>Session end hook</strong> — On manual end or timeout, bridge fires.</li>
<li><strong>Post-task hook (scheduled tasks)</strong> — After task completion, extract learnings before context resets.</li>
<li><strong>Task start injection (recurring tasks)</strong> — On scheduled task start, load relevant bridges from previous runs of the same routine.</li>
</ul>
<hr>
<h2 data-heading="Trigger Timing">Trigger Timing</h2>
<ul>
<li><strong>80-85% context usage</strong> is the sweet spot (enough tokens remaining to perform the extraction well)</li>
<li><strong>Never mid-tool-loop</strong> — wait for a clean conversational boundary to avoid corrupting message history</li>
<li><strong>On topic switch or end-of-work signals</strong> — natural session boundaries</li>
</ul>
<hr>
<h2 data-heading="Validation">Validation</h2>
<p>Built and tested in a personal AI agent harness running daily since April 2026. Multi-hour sessions across multiple channels (terminal, web, mobile). Open-sourced May 5, 2026.</p>
<p>Key findings:</p>
<ul>
<li>Categorization quality matters more than completeness</li>
<li>The handoff summary should be opinionated (not a transcript — "what does the next session need in the first 30 seconds?")</li>
<li>Trigger at 80-85%, not 90%+ (needs token budget to extract well)</li>
<li>Safe-point awareness prevents tool-loop corruption</li>
<li>The routed daily logs become the foundation for memory consolidation — the richer the logs, the better the synthesis</li>
</ul>
<p><strong>Timeline:</strong></p>
<ul>
<li>April 9, 2026 — First implementation committed</li>
<li>April 15, 2026 — Mid-tool-loop handoff added (edge case handling)</li>
<li>May 1, 2026 — Hardened for production</li>
<li>May 5, 2026 — Public release (<a href="https://github.com/monbishnoi/cal" class="external-link" target="_blank" rel="noopener nofollow" aria-label="https://github.com/monbishnoi/cal" data-tooltip-position="top">github.com/monbishnoi/cal</a>, v1.0.0)</li>
</ul>
<p>Reference implementation available in the linked repository.</p>## Summary
A pattern for preserving session context — not just compressing it — before a session resets. Session Bridge routes knowledge to permanent, structured storage rather than summarizing it into a flat file. It transforms ephemeral session state into durable, retrievable agent memory.
The core insight: Compaction is compression. Session Bridge is preservation.
Compaction asks "what can I forget?"
Session Bridge asks "where does this knowledge live permanently?"
Built and running in production since April 2026. Open-sourced May 5, 2026 ([reference implementation](https://github.com/monbishnoi/cal)).
5 Comments
@monbishnoi - The compaction vs preservation distinction would be a helpful feature! I'd be interested in deciding which discoveries are stored as team knowledge vs temporary run state. Otherwise, some preserved context can still become stale.
Great observation @teedole - this is exactly the next question after preservation: what kind of knowledge is this?
In our implementation, we handle this with a layered approach:
The "staleness" problem you're pointing at is real - we address it by treating consolidation as a merge operation, not just append. If something contradicts an existing fact, it flags for human review rather than silently overwriting.
For the team knowledge angle specifically: in a multi-agent or multi-user setup, the routing layer would need a "scope" dimension (personal vs. team vs. org). That's an interesting extension we haven't built yet.
Curious if you're thinking about this from a platform engineering / shared-agent perspective?
This framing matches what I am seeing from the repo-memory side: compression alone is not enough if the agent cannot later prove where a remembered claim came from or whether it is still current.
One design detail I would add to any structured context bridge is an evidence/validity layer around each durable memory item:
valid_at_sha: the git SHA where the memory was last verifiedsource: file/symbol/span, issue URL, command output, or user instructionpin: project, file, symbol, or task scope where it should resurfacestaleness_check: what invalidates it, such as changed file, moved symbol, deleted test, or superseding decisionchecked_surfaces: refs checked, likely tests checked, or explicitly "not checked"confidence: not as model vibes, but as a function of whether definitions/refs/tests were actually checkednext_action_if_insufficient: for example request more budget, run refs, run test_map, or ask userThat matters because long-running coding agents otherwise treat partial memory as proof. A useful memory bridge should let the next session ask: "what did we believe, why, and is it still true in this checkout?"
Disclosure: I build Sverklo, a local-first repo-memory/code-intelligence MCP, so I am biased toward auditable repo evidence. I am currently running public no-write proof receipts here, including failures where the receipt is misleading:
https://github.com/sverklo/sverklo/discussions/86
The most useful negative result so far: on
DeusData/codebase-memory-mcp, the proof command indexed 1,290 files and 217,203 symbol refs, but selected a vendored tree-sitter runtime symbol. That is exactly the kind of thing the memory layer should expose as "low quality for this purpose" rather than silently preserve.This proposal maps closely to LS work on durable trajectories, recovered evidence, and verified episodic memory.
One additional boundary may be useful:
context preserved
≠ context currently valid
≠ context verified
≠ context authorized to control execution
Lossless preservation solves disappearance, but resumed agents also need to know whether each preserved item is:
A possible bridge item could look like:
{
"schema_version": "session-bridge-item/v0.1",
"bridge_id": "bridge-001",
"trajectory_id": "project:billing-migration",
"source_continuation_id": "thread-before-reset",
"item_id": "decision-042",
"item_type": "DECISION",
"statement": "Use module B rather than patching module A",
"status": "CONFIRMED",
"source_refs": [
"user-message-188",
"tool-event-194"
],
"supersedes": [
"hypothesis-017"
],
"validity": {
"scope": "billing-migration",
"expires_at": null
}
}
An unresolved hypothesis should remain distinct:
{
"item_id": "hypothesis-021",
"item_type": "HYPOTHESIS",
"statement": "The failure may originate in the cache layer",
"status": "UNVERIFIED",
"evidence_refs": [],
"allowed_use": "GUIDE_INVESTIGATION"
}
The resumed session could evaluate preserved items through:
recover
→ match trajectory
→ check provenance
→ detect superseded or stale state
→ classify trust level
→ ACTIVE / ADVISORY / DEFER / IGNORE
The key invariant would be:
«Session Bridge should preserve epistemic status, not only information content.»
A second invariant:
«A recovered memory item may guide reasoning, but it should not authorize a side effect unless the normal execution and approval gates also pass.»
This would make the two proposed layers stronger:
Handoff
→ preserves the raw event and artifact history
Structured routing
→ places typed items into decision, knowledge, artifact, and work queues
Validation layer
→ determines whether each item remains applicable and enforceable
A bridge manifest could also retain artifacts without injecting all of them into model context:
{
"artifacts": [
{
"path": "docs/migration-decision.md",
"digest": "sha256:...",
"type": "DECISION_RECORD",
"load_policy": "ON_RELEVANT_QUERY"
},
{
"path": "reports/integration-test.json",
"digest": "sha256:...",
"type": "TEST_EVIDENCE",
"load_policy": "REQUIRED_BEFORE_COMPLETION"
}
]
}
A deterministic conformance fixture could test:
Related LS work:
https://github.com/safal207/LS/pull/651
https://github.com/safal207/LS/issues/594
https://github.com/safal207/LS/issues/595
https://github.com/safal207/LS/issues/597
https://github.com/safal207/LS/issues/630
Would a small vendor-neutral "SessionBridgeItem" and validation fixture help preserve not only context, but also its provenance, epistemic status, and execution relevance?
I’d separate the durable task from the remote-control session. The session is a disposable worker/lease: it can hit a quota, lose its network, or be replaced without making the task disappear.
For each task, keep a small state record outside the transcript: task id and monotonic revision, last accepted artifact, pending approval, lease owner and expiry, retry state, and an explicit terminal/dead reason. A reconnect should resume from that bounded state and replay missed revisions; it should not depend on the old conversation still being alive.
When a session becomes unavailable, the client should stop presenting it as alive and route new messages to the task inbox (or reject them visibly), rather than accepting input into a dead transcript. Background notifications should be idempotent projections of task state, so retries or quota resets cannot create duplicate or misleading messages. That turns a transient disconnect into “reconnect and resume task X,” while a real terminal failure remains visible and actionable.
I build cmdop, so I’m biased toward treating machines and sessions as contacts that can disappear while the task state remains durable.