---
title: "Context Alignment · pattern · Agentic Atlas"
description: "Context Alignment: the first efficiency strategy: co-schedule work that shares a context space, separate work that doesn't (moves relevancy by construction)."
canonical: "https://agentic-atlas.dev/nodes/context-alignment"
last-updated: "2026-09-14"
---

1. [Agentic Atlas](https://agentic-atlas.dev/)
2. [Patterns in the Agentic Atlas](https://agentic-atlas.dev/atlas)
3. [Context Efficiency](https://agentic-atlas.dev/nodes/context-efficiency)
4. Context Alignment
1. pattern
   # Context Alignment
   **Which tasks should share an agent’s context window, and which should run apart?**
   Context alignment groups work that shares a context space into one window and separates work that shares nothing, deciding per unit of work before it runs: co-schedule on high reusable overlap, dispatch to a fresh window on none, defer to a later session on overlap with work still to come. Relevancy is not optimized after the fact; it is set by what was admitted together.
   Hook
   the first efficiency strategy: co-schedule work that shares a context space, separate work that doesn't (moves relevancy by construction)
   Thesis
   Context alignment groups work that shares a context space into one window and separates work that shares nothing, deciding per unit of work before it runs: co-schedule on high reusable overlap, dispatch to a fresh window on none, defer to a later session on overlap with work still to come. Relevancy is not optimized after the fact; it is set by what was admitted together.
   Laws & fences
   - Estimate affinity, schedule by it, harvest relevancy. Affinity is a two-reading profile, reusable overlap and conflict risk, judged before scheduling because relevancy can only be measured once you are living in it; read the overlap dial as reuse, not resemblance, since a resident that shares the task's entities and topic without carrying anything the task will use sits at the dial's riskiest point, not its middle.
   - The answer to a bad break-even is to change regimes, not to optimize within one. When the shared space is a portable artifact, dollars wash out and you stay for latency, never for money, because the quality cost of staying compounds while the boot cost of leaving is fixed; when the space is trapped in the session's accreted understanding, one mid-session distillation into a handoff envelope makes it re-dispatchable and session-survivable from then on, an option premium bought in proportion to the odds the space is wanted again.
   - Defer to a later session only if the shared context space is persisted: session state evaporates at the boundary, so deferring with the space trapped in today's history is paying admission twice and calling it scheduling. The handoff artifact is an envelope crossing a seam whose sender no longer exists when the receiver reads, so it carries declared shape and provenance rather than a dump.
   When to reach
   - Reach for it when several units of work draw on one context space, the same codebase area, documents, or working state, and would each pay full admission for it if run apart, and when grouping is currently decided by whatever order requests arrived in one conversation.
   - Do not group sort-of related work, same subsystem but a different question, same entities but a different task: that is the isolate arm's defining case, since related material that carries no answer is the distractor measured to cost most. Skip the pattern for short episodic tasks that never leave their prime window, for tasks whose context space cannot be estimated before running, and for high conflict risk with no provenance on the conflicting claims.
   Provenance
   [context-alignment/intent-the-problem-and-the-move](https://agentic-atlas.dev/nodes/context-alignment#intent-the-problem-and-the-move) · v1.0.7
   Addresses
   atlas_cards context-alignment
2. [Context Efficiency](https://agentic-atlas.dev/nodes/context-efficiency)
3. [Momentum](https://agentic-atlas.dev/nodes/momentum)
4. [The Context Economy](https://agentic-atlas.dev/nodes/context-economy)
5. [Context Flow](https://agentic-atlas.dev/nodes/context-flow)
6. [Reference Data](https://agentic-atlas.dev/nodes/reference-data)
7. [LLM Dispatch](https://agentic-atlas.dev/nodes/llm-dispatch)
8. [The Contract](https://agentic-atlas.dev/nodes/contract-documentation)
9. [The Session Bill](https://agentic-atlas.dev/nodes/session-bill)
10. field notes
    - “the travelling declared-shape contract specialization”
    - “accumulated memory, a **separate concern from config**”

The ContractThe Session Bill unfold the map fold the map

The card, in place · its connections drawn edges from atlas_links context-alignment

On this plate

[intent-the-problem-and-the-move](https://agentic-atlas.dev/nodes/context-alignment#intent-the-problem-and-the-move) [use-when-the-shared-space-is-real-and-it-will-be-wanted-again](https://agentic-atlas.dev/nodes/context-alignment#use-when-the-shared-space-is-real-and-it-will-be-wanted-again) [avoid-when-nothing-to-amortize-or-affinity-unknowable](https://agentic-atlas.dev/nodes/context-alignment#avoid-when-nothing-to-amortize-or-affinity-unknowable) [forces](https://agentic-atlas.dev/nodes/context-alignment#forces) [structure-one-decision-per-unit-of-work-three-arms](https://agentic-atlas.dev/nodes/context-alignment#structure-one-decision-per-unit-of-work-three-arms) [application-estimate-schedule-convert](https://agentic-atlas.dev/nodes/context-alignment#application-estimate-schedule-convert) [consequences-and-tradeoffs](https://agentic-atlas.dev/nodes/context-alignment#consequences-and-tradeoffs) [verification](https://agentic-atlas.dev/nodes/context-alignment#verification) [examples-the-same-three-tasks-three-schedules](https://agentic-atlas.dev/nodes/context-alignment#examples-the-same-three-tasks-three-schedules) [relationships](https://agentic-atlas.dev/nodes/context-alignment#relationships) [lineage](https://agentic-atlas.dev/nodes/context-alignment#lineage) [open-questions-todo](https://agentic-atlas.dev/nodes/context-alignment#open-questions-todo) [relationships-ledger](https://agentic-atlas.dev/nodes/context-alignment#relationships-ledger)

Every section is addressable on its own. Read only the ground you need.

## Intent — the problem and the move

[Permalink to Intent — the problem and the move section](https://agentic-atlas.dev/nodes/context-alignment#intent-the-problem-and-the-move)

Two unrelated tasks run in one window gain nothing from sharing it: no context is reused, so no cost is amortized — and each task's context is the other's noise. At best that noise spends window length, which already costs accuracy on its own: a two-paragraph reasoning task padded from 250 to 3,000 tokens fell from 0.92 to 0.68 mean accuracy across five models ([Levy et al. 2024](https://aclanthology.org/2024.acl-long.818/)), and length degrades results even when the padding is whitespace ([Du et al. 2025](https://aclanthology.org/2025.findings-emnlp.1264/)). At worst — when the two tasks *look* alike — it supplies the near-miss distractors that are measured to cost the most: one in-topic sentence took a solved arithmetic set from 95.0 to 63.1 for code-davinci-002, where an off-topic sentence left it at 80.7 ([Shi et al. 2023](https://arxiv.org/abs/2302.00093)). Meanwhile tasks that *do* share a context space — same codebase area, same documents, same working state — pay full admission for it repeatedly when run apart. Grouping decisions are made implicitly today, by conversation accident, not by design.

The move: **schedule by context affinity.** Estimate, before running, how much of a task's context space is already resident and whether any of it contradicts what is there; co-schedule on high overlap, isolate on some or none, defer on overlap with work that comes later. Relevancy is not optimized after the fact — it is set by what was admitted together.

## Use when — the shared space is real, and it will be wanted again

[Permalink to Use when — the shared space is real, and it will be wanted again section](https://agentic-atlas.dev/nodes/context-alignment#use-when-the-shared-space-is-real-and-it-will-be-wanted-again)

- **Several units of work draw on one context space** — the same codebase area, the same documents, the same accreted working state — and would each pay full [admission](https://agentic-atlas.dev/glossary/admission) for it if run apart. Grouping pays admission and [residency](https://agentic-atlas.dev/glossary/residency) once and amortizes them across all N tasks.
- **The shared space is, or can be made, portable.** A stable artifact or a handoff *the travelling declared-shape contract specialization* can be re-admitted by a fresh window at will; that is what makes *isolate* and *defer* live options rather than names for re-deriving everything. The break-even below turns on this.
- **Grouping decisions are currently made by accident** — by whatever order requests arrived in one conversation — so relevancy is whatever the accident left. That is the default; alignment is the replacement.

## Avoid when — nothing to amortize, or affinity unknowable

[Permalink to Avoid when — nothing to amortize, or affinity unknowable section](https://agentic-atlas.dev/nodes/context-alignment#avoid-when-nothing-to-amortize-or-affinity-unknowable)

- **The task is short and [episodic](https://agentic-atlas.dev/glossary/episodic)** and never leaves its prime window. There is no residency to amortize and no decay to escape; a scheduling policy is more machinery than the session.
- **Affinity cannot be estimated before running.** The estimate is judgment made in advance; where a task's context space is unknown until it is underway, there is nothing to schedule on. Run it, harvest relevancy, and let the *observed* overlap inform the next dispatch.
- **Conflict risk is high and provenance is absent.** Two versions of one truth resident together with nothing that says which is current is the friction failure (*Consequences and tradeoffs*): the failure is wrong answers, and no amortization pays for that. Either carry the origin on each claim or do not co-schedule them.

## Forces

[Permalink to Forces section](https://agentic-atlas.dev/nodes/context-alignment#forces)

1. **Amortization against interference.** One admission shared across N tasks is the cheapest context there is; the same residency, read by a task it does not serve, is the most expensive. The two are the same tokens.
2. **Resemblance is not reuse.** Unrelated residents cost through length; residents that share the task's entities and topic without carrying its answer cost through misretrieval — and the second is larger per token where the two are measured side by side (six similar distractors cut Llama2-7B from 0.564 to 0.290 while six random ones left it at 0.568 — [Cuconasu et al. 2024](https://arxiv.org/abs/2401.14887); a single keyword-sharing distractor, placed well away from the needle, cut GPT-4o's effective length from 8K to 1K — [Modarressi et al. 2025](https://arxiv.org/abs/2502.05167)). One controlled study runs the other way — same-genre padding that shares no entities with the question cost *less* than unrelated padding ([Levy et al. 2024](https://aclanthology.org/2024.acl-long.818/), §4.2) — so the claim is about entity- and topic-sharing near-misses, not about genre.
3. **Affinity is estimated before; relevancy is observed after.** The scheduling decision runs on a prediction, and the measure that would confirm it exists only once the window is populated.
4. **Batching couples.** Grouping delays the later members of a group and binds them to a window that has been aging since the first member ran.
5. **Portability is bought before you know you will need it.** In-window continuity is free; a re-dispatchable shared space costs one distillation, paid in advance against a probability of return.

## Structure — one decision per unit of work, three arms

[Permalink to Structure — one decision per unit of work, three arms section](https://agentic-atlas.dev/nodes/context-alignment#structure-one-decision-per-unit-of-work-three-arms)

The decision per unit of work: *does this task's context space overlap the window's current residents?*

- **High overlap → co-schedule here (amortize).** The shared space is admitted once and stays load-bearing for every member of the group, so relevancy stays high through the group. Shared prefixes also cache.
- **Some or no overlap → dispatch to a fresh [window](https://agentic-atlas.dev/glossary/window-context-window) (isolate).** *"Sort of related"* — same subsystem, different question; same entities, different task — is this arm's defining case, not a borderline group: related material that carries no answer is the distractor measured to cost most (*Forces*). A new dispatch removes the other task's history — the boot (the always-on instructions and dispatch material a fresh window admits before any work) still consumes space — and the boot is cheaper than carrying a near-miss context space past the actor's effective length, the largest context at which it still holds 85% of its short-context accuracy (*Consequences and tradeoffs*).
- **Low overlap *now*, high overlap with work that comes later → defer.** Hold the task for the session that will hold its context space. This arm has a precondition: *defer to a later session* is only priced correctly if the shared space is **[persisted](https://agentic-atlas.dev/glossary/persistence)** — session state evaporates at the boundary, so deferring with the space trapped in today's history isn't deferral, it's paying admission twice and calling it scheduling. The move belongs to *accumulated memory, a **separate concern from config*** (the handoff artifact); the artifact's *form* is a *the travelling declared-shape contract specialization* crossing the [seam](https://agentic-atlas.dev/glossary/seam).

The economics are billed in [The Context Economy](https://agentic-atlas.dev/nodes/context-economy)'s three denominations — quality, dollars, latency — and described in [Context Flow](https://agentic-atlas.dev/nodes/context-flow)'s lifecycle: admit the shared space once, run the aligned group, evict.

**Affinity is a profile, not one signed scalar.** Two readings: **overlap** and **conflict risk**. Overlap is what an estimator can read before running — shared files, entities, topic, working state — and it is read in **three bands**, because risk is not monotonic in it: *none* costs through length and is the cheapest cohabitant; *some* — resemblance without reuse — is the costliest, the near-miss band (*Forces*); *high* is reuse, the only band worth grouping. Conflict risk (none → high) predicts a different failure — friction — and it is not overlap turned up (*Consequences and tradeoffs* names both). Conflict also arises *within* one task's context — stale documentation beside current code — not only between grouped tasks.

### The aligned-batch break-even *(ruled 2026-07-05)*

Where does task N+1 in-window start costing more than a fresh dispatch that re-admits the shared space? Answered by a **regime split on where the shared context space lives**, not by a single crossover:

- **Portable regime** — the shared space is a stable artifact or envelope (or a still-warm cached prefix, but cache TTLs are minutes, so in practice: *artifacts*). Re-admission is cheap for a fresh dispatch, so **dollars wash out** of the comparison. What remains is a *fixed* latency cost of leaving (boot) against a quality cost of staying that grows with residence — tasks 1..N's residue — and, past the actor's effective length, is measured to fall steeply. One side is bounded and the other is not, so the crossover comes much earlier than dollar-intuition suggests. **You stay for latency, never for money.**
- **Trapped regime** — the shared space is understanding accreted across the session (files read on demand, discoveries, judgment calls), never distilled out. A fresh dispatch cannot re-admit it at any cache price; it must *re-derive* it — full input dollars, full latency, plus the risk of deriving it *differently*. Here staying in-window genuinely is cheaper, for a while. Cache hits cannot be counted on across a re-dispatch, so the dollar term is real in this regime — and only in this regime.
- **The conversion move — the actual answer.** One distillation cost, paid mid-session, converts trapped → portable. Write the handoff envelope and the shared space is re-dispatchable — and session-survivable — from then on. **The answer to a bad break-even is to change regimes, not to optimize within one.**
- **The intentionality asymmetry.** In-window continuity is the default you get for free; portability is an *opt-in purchase* made before you know whether you will return — an **option premium**. Its value scales with the probability the context space is wanted again.

At the session boundary the regimes harden: portable is unchanged — that is the point of artifacts — while trapped goes from *expensive to move* to *gone*. And the handoff artifact is not a dump: session A → session B is a seam whose sender no longer exists when the receiver reads, so there is no back-channel to clarify across — the purest case for the envelope's declared shape plus provenance.

## Application — estimate, schedule, convert

[Permalink to Application — estimate, schedule, convert section](https://agentic-atlas.dev/nodes/context-alignment#application-estimate-schedule-convert)

1. **Estimate affinity per unit of work, on both readings.** Name the context space the task needs (which files, which documents, which working state) and read it against what is resident: how much is reusable, and does any of it contradict what is already there? The estimate is a profile with two readings, one of them banded — not a similarity score.
2. **Schedule by the profile.** High overlap, low conflict → run it here. Some or no overlap → fresh window. High conflict → provenance on every conflicting claim before it is admitted, or isolation. Overlap with work not yet scheduled → defer, *if* the space is persisted.
3. **Watch the crossover, and change regimes rather than fight it.** In the portable regime, leave when the group's residue starts costing quality — which is earlier than the bill suggests. In the trapped regime, the question is not *how long can I stay* but *when do I write the envelope*: the conversion is one distillation cost, and once paid it makes every later leave cheap.
4. **Buy the option premium on a signal, not by default.** Portability is worth paying for in proportion to the probability the space is wanted again. The signals that predict that are unvalidated; the working rule is that a task family with known future members is a purchase and a one-off is not.

## Consequences and tradeoffs

[Permalink to Consequences and tradeoffs section](https://agentic-atlas.dev/nodes/context-alignment#consequences-and-tradeoffs)

**Benefits.** [Admission](https://agentic-atlas.dev/glossary/admission) and [residency](https://agentic-atlas.dev/glossary/residency) of the shared space are paid once and amortized ÷N across the group; shared prefixes also cache. The shared context is load-bearing for every member, so relevancy stays high through the group without any per-turn pruning. The fresh window for a zero-overlap task buys relevancy bounded only by its boot material, at the price of one boot.

**The two failure modes of a bad estimate, and they are not one failure.**

- **Interference** — non-load-bearing residents. The price rises with resemblance: unrelated filler spends length; near-miss material is what costs accuracy (*Forces*). Retrieved-but-wrong context can be worse than none: GPT-3.5-Turbo's 56.1% closed-book beat its own accuracy with 20 or 30 retrieved documents when the answer sat mid-window ([Liu et al. 2024](https://aclanthology.org/2024.tacl-1.9/)) — the condition is retrieved distractors, which is exactly what a *sort-of* related task contributes.
- **Friction** — contradictory claims resident together: two versions of one API doc, stale docs beside current code, opposite conventions in one window. Friction fails differently from interference — not a lower score on the task but **a confident answer drawn from the wrong document, with the model's confidence barely moved**. Told to expect a conflict between two passages in one prompt, GPT-4 surfaced both 10.4% of the time and Llama-3-70B 43.8% — unprompted, 6.3% and 10.4% — and most of the rest picked one ([Hou et al. 2024](https://arxiv.org/abs/2406.13805)). Which one is decided by cues that do not track truth — how many passages agree ([Jin et al. 2024](https://aclanthology.org/2024.lrec-main.1466/)), which scored highest at retrieval ([Chen et al. 2022](https://aclanthology.org/2022.emnlp-main.146/)), which came first (order alone swings the answer 5–30% — [Xie et al. 2024](https://proceedings.iclr.cc/paper_files/paper/2024/hash/99261adc8a6356b38bcf999bba9a26dc-Abstract-Conference.html)), and the model's prior. Whether friction costs *more* than interference is not measured; no study runs the two head-to-head. What is measured is that it costs differently, and that a window cannot see it from inside.

**Where conflict is unavoidable, the antidote is provenance** — and it is a handle, not a lock. The *the travelling declared-shape contract specialization*'s declared origin is the one cue in the window that tracks truth; without it, relevance, majority, order, and prior decide. Per-document credibility labels in the prompt moved ChatGPT's accuracy on misinformation-polluted and time-evolving QA by +0.09 to +0.18 absolute, a 7B model by less, and the large gains needed training ([Pan et al. 2024](https://arxiv.org/abs/2404.06809)); a declared source frame cut text-davinci-003's reversion to its memorized answer from 35.2% to 11.0% — a model-versus-document setting, not two documents, but the same lever ([Zhou et al. 2023](https://aclanthology.org/2023.findings-emnlp.968/)). Timestamps are read too — as a bias: injected dates on passages of identical relevance reversed pairwise preference by up to 25% on average ([Fang et al. 2025](https://arxiv.org/abs/2509.11353)). **Recency is not truth**; declared origin says where a claim came from, and the actor still has to rule.

**Costs and new obligations.** Grouping couples tasks: batching adds latency for the later members, and over-grouping — *"these are sort of related"* — is where the measured damage concentrates: it drifts the window past the actor's **effective length** (the largest context at which a model still holds 85% of its short-context accuracy — measured per model, and it varies by two orders of magnitude across the models of a single benchmark's table ([Hsieh et al. 2024](https://arxiv.org/abs/2404.06654)); the four headline models of another sit at 8K, 4K, 2K and 2K against claimed windows of 128K and more ([Modarressi et al. 2025](https://arxiv.org/abs/2502.05167))) carrying context that is load-bearing for none of the current work. Affinity has to be known up front, and estimating a task's context space before running it is judgment that can miss. And the deferral arm creates an artifact obligation: a handoff envelope that must exist before the session boundary, or the deferral never happened. The full research trail is in the interference-and-conflict synthesis.

## Verification

[Permalink to Verification section](https://agentic-atlas.dev/nodes/context-alignment#verification)

**Deterministic:**

- **Admission moved from N to 1.** Count the shared space's admissions across the group: grouped, it is admitted once; isolated or interleaved across sessions, once per task. Residency arithmetic in token-turns — tokens resident × turns resident — is checkable on any declared scenario, and the example below runs it.
- **The window's residents are the group's residents.** At any turn, list what is resident and ask which task each artifact serves. Under alignment the answer is *this group*; under interleaving, some fraction serves a task that is not running. That fraction is countable by inspection.
- **The deferral arm has its artifact.** If a task was deferred, the handoff envelope exists, carries declared shape and provenance, and was written before the boundary — or the deferral was not one.

**Probabilistic residue:**

- **Relevancy is an analytic lens, not a benchmark.** *Load-bearing for the task at hand* is a judgment per artifact; the reading is the eviction-counterfactual inspection stated at [Context Efficiency](https://agentic-atlas.dev/nodes/context-efficiency) *(ruled 2026-09-10 — ADR 0021)*, and the resident-by-task listing above is how it is taken.
- **The quality cost of staying is not visible from inside the window.** Decay past the optimum is silent; only scored outcomes on the group's later tasks show it, which means the crossover is confirmed after the fact.
- **Friction shows up as a wrong answer, not a slow one.** It is caught by checking the answer's source against the current truth, not by any measure of window occupancy.

## Examples — the same three tasks, three schedules

[Permalink to Examples — the same three tasks, three schedules section](https://agentic-atlas.dev/nodes/context-alignment#examples-the-same-three-tasks-three-schedules)

Declared inputs, billed in token-turns (tokens resident × turns resident) for the terms the arithmetic reaches; the quality term is named and not numbered.

Three tasks each need the same **8,000-token** shared space (one subsystem's source and its design note); each runs **10 turns** and adds **1,000 tokens** of its own work per turn. The space is portable — a file on disk — so any window can admit it.

| Schedule | Admissions of the shared space | Boots | Residue read (token-turns) | What the residue is |
| --- | --- | --- | --- | --- |
| **Three fresh windows** | 3 | 3 | 0 | — |
| **One window, interleaved** (A, B, C, A, B, C, …) | 1 | 1 | 300,000 | the other two tasks' half-done turns |
| **One window, grouped** (A's ten turns, then B's, then C's) | 1 | 1 | 300,000 | the group's own finished work |

Residue is every token a turn reads that belongs to a task other than the one running. Grouped: each of B's ten turns carries A's 10,000 finished tokens and each of C's carries 20,000 — 100,000 + 200,000. Interleaved: turn *t* of thirty carries (*t* − 1) thousand prior tokens, of which the running task's own share is one third — the same 300,000 by a different route. The shared space itself is resident for thirty turns under every schedule (240,000 token-turns), so it is not where the schedules differ.

Three fresh windows → one grouped window is the first delta: two boots and two admissions saved, in latency; paid for with 300,000 token-turns of residue, in dollars. That is the portable regime's law in one row — **you stay for latency, never for money.** Interleaved → grouped is alignment's own delta: same admissions, same boot, the same 300,000 token-turns of residue — and the only thing that changed is *what the residue is*. Interleaved, every turn reads two other tasks' in-progress state — near-miss material if the tasks resemble each other, length if they do not; grouped, it reads the shared space and the group's finished conclusions, which the later members reuse. The table cannot bill that difference. It is the quality term, and it is where the break-even lives. Two further schedules would price it — a group that overstays the actor's effective length, and a group that writes a handoff envelope mid-session and re-dispatches — and neither is measured here. No primary source gives a per-turn decay slope to bill the first against; the one multi-turn measurement that exists — a −39% average drop when a fully specified task is delivered across turns instead of at once ([Laban et al. 2025](https://arxiv.org/abs/2505.06120)) — is a step at the second turn caused by under-specification, not a curve over residence.

## Relationships

[Permalink to Relationships section](https://agentic-atlas.dev/nodes/context-alignment#relationships)

- **Child of [Context Efficiency](https://agentic-atlas.dev/nodes/context-efficiency)** — the first strategy under the objective; it moves the state measure (relevancy) directly. [Context Flow](https://agentic-atlas.dev/nodes/context-flow) supplies the lifecycle vocabulary; alignment owns *what goes together*.
- **Priced by [The Context Economy](https://agentic-atlas.dev/nodes/context-economy):** amortized admission is the time-value arithmetic shared across N tasks; interference is the quality denomination spent for nothing.
- **Motivates [LLM Dispatch](https://agentic-atlas.dev/nodes/llm-dispatch) from a new angle:** a fresh window is the zero-overlap escape hatch — 100% relevancy at the price of one boot cost.
- **The deferral arm depends on *accumulated memory, a **separate concern from config***** (the handoff move) and on the *the travelling declared-shape contract specialization* (the handoff's *form*): the session boundary is a time-shaped leg of the envelope's topology — same travelling contract, sender gone by read time. Alignment prices the decision; those nodes own the moves. The handoff artifact's shape derives from [The Contract](https://agentic-atlas.dev/nodes/contract-documentation)'s anatomy.
- **Fenced from [Momentum](https://agentic-atlas.dev/nodes/momentum):** friction is contradiction resident in the window; momentum is the window steering generation. Momentum's own not-friction fence draws the same line from the other side.

## Lineage

[Permalink to Lineage section](https://agentic-atlas.dev/nodes/context-alignment#lineage)

Coupling and cohesion (Stevens, Myers & Constantine, *Structured Design*, IBM Systems Journal, 1974): group what belongs together, and make what does not belong together depend on each other as little as possible. Alignment is that pair applied to scheduling rather than to modules — reusable overlap is cohesion within a window, interference and friction are coupling costs paid by co-residency. The delta: a module boundary is drawn once and holds; a window's membership is re-decided every dispatch, and the cost of a bad grouping compounds with residency instead of staying fixed.

## Open questions / TODO

[Permalink to Open questions / TODO section](https://agentic-atlas.dev/nodes/context-alignment#open-questions-todo)

- **The persistence tells.** The option premium is worth paying when the context space will likely be wanted again; the concrete signals that predict it are not yet collected. Candidates awaiting validation against real sessions: a task family with known future members; a subtree mid-campaign; an expensive derivation you would hate to redo; a recurring chore.
- **The four-arm bill.** The example above bills two schedules; the full bill adds a group that overstays the actor's effective length and a group that converts mid-session with a handoff envelope and re-dispatches — one decision shift per arm, billed in the economy's three denominations. The overstay arm bills its quality term as an effective-length crossing on a named model; no turn-indexed decay curve exists to bill against.

The relationships ledger

Evidence-bearing references

## Relationships

Every connection keeps the section where it was found. The map above orients; this ledger carries the evidence.

### Outbound references 15

1. undisclosed · occurrence 1
   Undisclosed relationship
   the travelling declared-shape contract specialization
   Evidence: [Use when](https://agentic-atlas.dev/nodes/context-alignment#use-when-the-shared-space-is-real-and-it-will-be-wanted-again) · occurrence 1
2. undisclosed · occurrence 1
   Undisclosed relationship
   accumulated memory, a **separate concern from config**
   Evidence: [Structure](https://agentic-atlas.dev/nodes/context-alignment#structure-one-decision-per-unit-of-work-three-arms) · occurrence 1
3. undisclosed · occurrence 2
   Undisclosed relationship
   the travelling declared-shape contract specialization
   Evidence: [Structure](https://agentic-atlas.dev/nodes/context-alignment#structure-one-decision-per-unit-of-work-three-arms) · occurrence 2
4. in-slice · occurrence 3
   [The Context Economy](https://agentic-atlas.dev/nodes/context-economy)
   **statics** — the price list: denominations, the quality curve, cost classes, time value
   Evidence: [Structure](https://agentic-atlas.dev/nodes/context-alignment#structure-one-decision-per-unit-of-work-three-arms) · occurrence 3
5. in-slice · occurrence 4
   [Context Flow](https://agentic-atlas.dev/nodes/context-flow)
   **dynamics** — admission, residency, and eviction; placement and recall within residency
   Evidence: [Structure](https://agentic-atlas.dev/nodes/context-alignment#structure-one-decision-per-unit-of-work-three-arms) · occurrence 4
6. undisclosed · occurrence 1
   Undisclosed relationship
   the travelling declared-shape contract specialization
   Evidence: [Consequences and tradeoffs](https://agentic-atlas.dev/nodes/context-alignment#consequences-and-tradeoffs) · occurrence 1
7. in-slice · occurrence 1
   [Context Efficiency](https://agentic-atlas.dev/nodes/context-efficiency)
   **objective** — value per unit of context spent (cost / state / outcome lenses)
   Evidence: [Verification](https://agentic-atlas.dev/nodes/context-alignment#verification) · occurrence 1
8. in-slice · occurrence 1
   [Context Efficiency](https://agentic-atlas.dev/nodes/context-efficiency)
   **objective** — value per unit of context spent (cost / state / outcome lenses)
   Evidence: [Relationships](https://agentic-atlas.dev/nodes/context-alignment#relationships) · occurrence 1
9. in-slice · occurrence 2
   [Context Flow](https://agentic-atlas.dev/nodes/context-flow)
   **dynamics** — admission, residency, and eviction; placement and recall within residency
   Evidence: [Relationships](https://agentic-atlas.dev/nodes/context-alignment#relationships) · occurrence 2
10. in-slice · occurrence 3
    [The Context Economy](https://agentic-atlas.dev/nodes/context-economy)
    **statics** — the price list: denominations, the quality curve, cost classes, time value
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/context-alignment#relationships) · occurrence 3
11. in-slice · occurrence 4
    [LLM Dispatch](https://agentic-atlas.dev/nodes/llm-dispatch)
    the parent-child execution primitive; serial, parallel, joined, or fire-and-forget
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/context-alignment#relationships) · occurrence 4
12. undisclosed · occurrence 5
    Undisclosed relationship
    accumulated memory, a **separate concern from config**
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/context-alignment#relationships) · occurrence 5
13. undisclosed · occurrence 6
    Undisclosed relationship
    the travelling declared-shape contract specialization
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/context-alignment#relationships) · occurrence 6
14. in-slice · occurrence 7
    [The Contract](https://agentic-atlas.dev/nodes/contract-documentation)
    expectations at a seam, from informal prose to enforced structure
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/context-alignment#relationships) · occurrence 7
15. in-slice · occurrence 8
    [Momentum](https://agentic-atlas.dev/nodes/momentum)
    resident context steers, not just informs — path dependence, and eviction's second motive
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/context-alignment#relationships) · occurrence 8

### Inbound references 9

1. in-slice · occurrence 1
   [Context Efficiency](https://agentic-atlas.dev/nodes/context-efficiency#model-and-claims)
   the first efficiency strategy: co-schedule work that shares a context space, separate work that doesn't (moves relevancy by construction)
   Evidence: [Model and claims](https://agentic-atlas.dev/nodes/context-efficiency#model-and-claims) · occurrence 1
2. in-slice · occurrence 1
   [Context Efficiency](https://agentic-atlas.dev/nodes/context-efficiency#scope-and-boundaries)
   the first efficiency strategy: co-schedule work that shares a context space, separate work that doesn't (moves relevancy by construction)
   Evidence: [Scope and boundaries](https://agentic-atlas.dev/nodes/context-efficiency#scope-and-boundaries) · occurrence 1
3. in-slice · occurrence 4
   [Context Efficiency](https://agentic-atlas.dev/nodes/context-efficiency#implications-the-consequence-map)
   the first efficiency strategy: co-schedule work that shares a context space, separate work that doesn't (moves relevancy by construction)
   Evidence: [Implications](https://agentic-atlas.dev/nodes/context-efficiency#implications-the-consequence-map) · occurrence 4
4. in-slice · occurrence 3
   [Context Efficiency](https://agentic-atlas.dev/nodes/context-efficiency#relationships)
   the first efficiency strategy: co-schedule work that shares a context space, separate work that doesn't (moves relevancy by construction)
   Evidence: [Relationships](https://agentic-atlas.dev/nodes/context-efficiency#relationships) · occurrence 3
5. in-slice · occurrence 1
   [Momentum](https://agentic-atlas.dev/nodes/momentum#scope-and-boundaries-three-fences-and-a-test)
   the first efficiency strategy: co-schedule work that shares a context space, separate work that doesn't (moves relevancy by construction)
   Evidence: [Scope and boundaries](https://agentic-atlas.dev/nodes/momentum#scope-and-boundaries-three-fences-and-a-test) · occurrence 1
6. in-slice · occurrence 4
   [Momentum](https://agentic-atlas.dev/nodes/momentum#relationships)
   the first efficiency strategy: co-schedule work that shares a context space, separate work that doesn't (moves relevancy by construction)
   Evidence: [Relationships](https://agentic-atlas.dev/nodes/momentum#relationships) · occurrence 4
7. in-slice · occurrence 1
   [Reference Data](https://agentic-atlas.dev/nodes/reference-data#consequences-and-tradeoffs-and-the-crossover)
   the first efficiency strategy: co-schedule work that shares a context space, separate work that doesn't (moves relevancy by construction)
   Evidence: [Consequences and tradeoffs](https://agentic-atlas.dev/nodes/reference-data#consequences-and-tradeoffs-and-the-crossover) · occurrence 1
8. in-slice · occurrence 6
   [Reference Data](https://agentic-atlas.dev/nodes/reference-data#relationships)
   the first efficiency strategy: co-schedule work that shares a context space, separate work that doesn't (moves relevancy by construction)
   Evidence: [Relationships](https://agentic-atlas.dev/nodes/reference-data#relationships) · occurrence 6
9. in-slice · occurrence 6
   [The Session Bill](https://agentic-atlas.dev/nodes/session-bill#implementation-the-six-shifts)
   the first efficiency strategy: co-schedule work that shares a context space, separate work that doesn't (moves relevancy by construction)
   Evidence: [Implementation](https://agentic-atlas.dev/nodes/session-bill#implementation-the-six-shifts) · occurrence 6

[↑ back to the top](https://agentic-atlas.dev/nodes/context-alignment#content) [← the survey](https://agentic-atlas.dev/atlas)

Node context-alignment · corpus 533727d · Catalog revision a9f60f26fd5ef6a1e0bbb39e8d0de32bf9c464b8c7b8ee3fc8c8c9fdb3a1021a