Context Patterns¶
How much context each tier carries, across what scope, and for how long. The pollution-vs-continuity surface.
[TUNABLE — context usage]
This page is about a simple question: how much should each AI agent in your team remember, and for how long? Remember too little and it keeps re-learning the same things; remember too much and it gets cluttered, slow, and confused. The settings below ("dials") let you tune that balance — and the defaults are chosen so you don't have to fiddle until you have a reason to.
TL;DR¶
A quick map before the detail: each tier (the senior planner, the mid-level coordinator, and the hands-on worker) carries its own "memory load," and you can adjust how big it is and how often it gets a clean slate.
Several independent dials control how much context each tier holds and over what scope: mentor session lifecycle, doer context depth, cross-tier visibility, memory accumulation rate, digest verbosity, and rotation cadence. These trade pollution-containment and cost against continuity and intelligence. The conservative defaults bias toward containment (fresh-per-event sessions, own-folder-only visibility, verbose digests). They are largely independent — combining them differently yields the operating presets. The firewall and hard labour rule are [INVARIANT] underneath all of them.
The dials¶
1. Mentor session lifecycle¶
How long a tier keeps one session before refreshing.
| Lifecycle | Applies to | Pollution | Boot overhead | Continuity |
|---|---|---|---|---|
| Fresh-per-event (default for Mentor-2 + Doer) | mid + bottom tiers | lowest | highest per event | lowest |
| Per-dispatch (alt for Mentor-2) | mid tier | moderate | lower | moderate |
| Long-running (default for Mentor-1) | top tier | managed via down-tier freshness | lowest | highest |
The structural rule (context health hygiene) is fresh-session bias increases down-tier: the top mentor runs long (continuity matters there), the mid mentor rotates per dispatch or event, and the Doer is always fresh-per-slice. The Doer's fresh-per-slice rule is [INVARIANT] — reusing a Doer session across slices is an anti-pattern (fatigue + cross-slice pollution). What's tunable is the mid-tier choice (fresh-per-event vs per-dispatch) and the top-tier rotation cadence.
2. Doer context depth¶
How much the Doer reads to do its slice.
- Wide / liberal (default). The Doer reads what it needs to triangulate — sibling documents, cross-files in substrate, related memories. Maximum intelligence; highest token cost.
- Narrow / declared-only. The Doer reads only the files explicitly listed in its brief. Lower cost; risk of missing critical context.
Wide is the right default for substantive work where the Doer must reason across the codebase. Narrow suits cosmetic or tightly-scoped slices where the brief genuinely contains everything.
3. Cross-tier visibility scope¶
What each tier is allowed to read of other tiers.
- Own-folder only (default). Each tier sees only its own folder + the inboxes it receives. Maximum pollution containment. This is the firewall at its strictest.
- Parent-folder-summary. A lower tier may read its parent's summary state. Higher continuity awareness; a small, deliberate pollution leak.
- Full visibility (anti-pattern — not recommended). All tiers read all folders. Maximum continuity, pollution chaos. Documented only so adopters recognize and avoid it.
Note the relationship to the firewall axiom: own-folder-only is the firewall. Loosening to parent-summary is a deliberate, bounded relaxation; full visibility breaks the axiom and is off the table.
4. Memory accumulation rate¶
How readily the federation captures durable cross-cycle learnings.
- Liberal (default). Capture a memory for every meaningful learning. The federation matures fast; the memory file count grows.
- Conservative. Capture memories only for patterns proven across two or more incidents. Less noise; slower maturation.
This dial is covered in depth on the Memory policy page; it lives here too because it is fundamentally a context dial.
5. Audit / digest verbosity¶
How much detail a tagged return carries up-tier.
- Verbose (default). Tagged returns include full digests — findings, open questions, surprising reads. Rich audit trail; higher cost.
- Concise. Tagged returns include only deltas + status. Thinner audit trail; lower cost.
Verbose pays off where the audit trail is load-bearing (regulated work, post-hoc forensics). Concise suits high-throughput, lower-stakes work.
6. Rotation cadence¶
How often the long-running top mentor is preventively rotated to a fresh session at a clean seam.
- Default: 2–4 weeks preventive, plus reactive rotation on any context-health signal.
- Range: 1–6 weeks. Tighter cadence (1–2 weeks) lowers pollution risk at the cost of continuity and rotation overhead; looser cadence (4–6 weeks) preserves continuity but accumulates more session fatigue.
Rotation is always also reactive: the moment a tier shows context-health signals (responses lengthening without added content, recognition fuzziness, needing to re-read what should be known), it flushes and rotates regardless of the calendar. Do not push through fatigue.
Keeping fresh-per-event actually fresh¶
Fresh-per-event only pays off if a fresh session boots light. The failure mode: every fresh tier re-reads the entire on-disk state at boot, so boots get slow and the freshly-booted session is immediately as loaded as the one it replaced — slow and fatigued at once, defeating the whole point of refreshing.
Two disciplines keep the dial honest:
- Flush load-bearing deltas, not everything. The persistence law requires durable state on disk before disclosure — it does not mean writing the full transcript. Flush the decisions, tags, and ledger entries the next session needs; not the reasoning footprints it doesn't.
- Boot reads a compact digest, not full history. A fresh session reads the last tagged return + the ledger summary + its own inbox — enough to act, no more. It does not re-ingest prior transcripts or sibling history. If returns are heavy, turn digest verbosity down (dial 5 above).
Trimming the load is never discarding knowledge. Boot-light governs what a session reloads into working context — not what is kept. Two things preserve the low-frequency but genuinely valuable insights that surface in discussion (heuristics, design rationale, why an option was rejected):
- Git keeps everything. The full transcript and every prior state live in the commit history (the durability layer) and stay retrievable by tag or commit. A compact boot does not delete them.
- Harvest before you trim. When a routine discussion surfaces a durable heuristic or an important rationale, promote it to the memory layer as a provenance-cited memory entry before the session refreshes. Memory inheritance is the channel that carries those forward across boots and cycles.
Boot-light is safe because durable learnings live in memory and git — never only in the volatile transcript. If you're unsure whether something is worth keeping, harvest it: a cheap memory entry beats a lost insight.
A slow, fatigued fresh session is an over-load signal
If fresh boots are slow and a just-booted tier already shows fatigue (losing one-liners, re-reading what it just read), the boot is loading too much — tighten what's flushed and what's read, not the rotation cadence. A correctly-scoped boot is fast and clean; that is the entire return on fresh-per-event. (When the relay overhead itself is the bottleneck across all tiers, that's a signal to revisit the concurrency / delegation mode, not just the boot weight.)
Defaults¶
| Dial | Default | Range |
|---|---|---|
| Mentor-1 lifecycle | long-running (per-cycle) | per-cycle / per-epoch |
| Mentor-2 lifecycle | fresh-per-event | fresh-per-event / per-dispatch |
| Doer lifecycle | fresh-per-slice | [INVARIANT] — not tunable |
| Doer context depth | wide / liberal | wide / narrow / declared-only |
| Cross-tier visibility | own-folder only | own-only / parent-summary / full (anti-pattern) |
| Memory accumulation rate | liberal | liberal / conservative |
| Digest verbosity | verbose | verbose / concise |
| Rotation cadence | 2–4 weeks preventive | 1–6 weeks |
How to choose¶
- Stay at the defaults for regulated/high-stakes work. Containment and audit depth are worth the cost.
- Loosen Doer context to narrow only when slices are genuinely self-contained (cosmetic, single-file). Otherwise wide.
- Switch digests to concise only for high-throughput lanes where you don't need forensic depth.
- Tighten rotation cadence if you observe fatigue signals before the calendar; loosen if rotations feel premature.
- Never go to full cross-tier visibility. It breaks the firewall axiom; use parent-summary if you genuinely need more continuity awareness.
Remember this¶
- A "dial" is just a setting for how much an agent remembers and over what scope. There are six of them, and they're mostly independent — you can turn one without disturbing the others.
- The defaults lean toward "keep it clean." Fresh sessions, see-only-your-own-folder, detailed records. That's the safe starting point; loosen a dial only when you have a concrete reason.
- A fresh start is not amnesia. Anything worth keeping lives in git and in the memory layer before a session refreshes — so booting light reloads less, it never throws knowledge away.
- The lower the tier, the more often it should start fresh. The senior planner runs long for continuity; the hands-on worker gets a clean slate for every task. If unsure how the tiers fit together, see the mental model.
How this connects¶
- Firewall (axiom) — cross-tier visibility is the firewall's tunable dial; own-folder-only is the firewall at strictest.
- Hard labour rule (axiom) — keeps mentor context clean regardless of lifecycle choice.
- Pollution containment (guardrail) — the down-tier freshness bias these lifecycle dials implement.
- Memory policy — the memory accumulation dial in full.
- Retrieval surface — how a fresh or loaded tier reloads only the relevant slice on demand, instead of re-ingesting full history; the retrieval mechanism behind boot-light.
- Concurrency modes — parallel concurrency pressures the top mentor's context, interacting with lifecycle + rotation.