Context and state
Context engineering at the model boundary
| Model call | Repository evidence in the input | What the model can determine |
|---|---|---|
| Before the lookup | No tags supplied | The model knows the release rule and can request the tags. It cannot yet identify a release from the repository. |
| After the lookup | list_git_tags returned tags including v1.2.3 | The model can identify v1.2.3 as a candidate. To choose it as the newest release, the returned evidence must also establish how it ranks among qualifying tags. |
A tool definition tells the model what it can ask the application to look up. A tool result tells it what that lookup returned. Both take space in the context window, the limit on how many tokens a model can process in one call, including the response it generates. Tokens are the units in which the model represents text. The user’s request, earlier exchanges, and any required output format also use that space. Instructions and demonstrations guide the response by describing the desired behavior or showing an example, all with the model’s learned parameters held fixed. Tokens and vocabulary IDs · Prompt design · Learning from demonstrations
How practitioners described the work
In April 2025, Horthy showed two ways to give a model the same deployment history: serialize it as messages or render the request, lookup, and result in an event format chosen by the application. That month, Ankur Goyal of Braintrust also used the term context engineering. He emphasized collecting relevant information from across the software stack and choosing a format for the large language model (LLM). In the agent runs he examined, tool definitions and responses accounted for much of the input. Inspecting only the written instructions would miss much of what those models actually saw. Goyal’s April account · Goyal’s analysis of agent runs
A decision made during the task can itself become necessary input. On June 12, Walden Yan of Cognition illustrated this with a hypothetical Flappy Bird game. Two workers receive the same game description and independently make assets. Once one chooses a visual style, the other needs that choice to produce a matching asset. Repeating the original goal more precisely cannot communicate a choice made afterward. On June 23, Harrison Chase of LangChain drew on Yan, Goyal, and Tobi Lütke to describe a changing per-call responsibility that includes tools as well as information and format. Yan’s game example · Lütke on supplying enough context · Chase’s synthesis
Retained state and current input
A source record answers a question about a particular object or event. Task state records the goal, accepted progress, and work still open. Conversation history preserves what participants said, including suggestions and unverified claims. The effective input is what the model actually receives for one invocation. A conversation identifier can locate a history, but the service’s continuation rules determine which material it processes. Persistent memory has a separate purpose and lifetime, such as retaining a preference for use in a future conversation. Memory across interactions
A trace is a record of a run. In Alyx at Arize, keeping a large trace in conversation history caused repeated overflow. Cutting it down could remove a field that a user asked about later. The team’s LargeJSON design keeps the full trace on the server. One call receives a structured preview and a json_id. A later call can use the identifier to request a particular field. Follow the two paths from the server record in the figure. The field comes from the original trace, so the model need never reconstruct it from the preview. Arize’s engineering account · Sally-Ann DeLucia’s talk
Two reads of one trace
A later call can recover a field the first call never saw.
Read the diagram as text
- Full trace on server.
- First model input.
- Targeted lookup.
- Later model input.
- Full trace on server → First model input: Preview and json_id.
- First model input → Targeted lookup: Use json_id to request a field.
- Full trace on server → Targeted lookup: Original field data.
- Targeted lookup → Later model input: Requested value.
Information can also enter a call without becoming history. The Strands ContextInjector can supply the current time just for that invocation. These separate lifetimes matter when a task ends. Closing the task or leaving a message out of the next request can leave a stored record, a checkpoint of earlier state, and text derived from it available for other uses. Strands Context Injector
Assembling a request
Start with the question the model must answer and the requester on whose behalf it will answer. Retrieval finds candidate material. Before a record enters the input, the application must establish that the requester may see it and that it applies to the question. It can then select fields, associate them with the request or tool call that produced them, and check the assembled input. Provenance records where information came from and how it was transformed. Keeping a source identifier, revision, and observation time can make a rendered sentence traceable back to the record that supports it. Search and Retrieval · W3C PROV Data Model
Suppose the question is whether a GitHub check passed on a particular commit. Authenticate the lookup in application code and keep its credentials out of the model input. Look up the requested check, then compare its run’s head_sha with the requested commit. When both the check and commit match, retain the run ID, status, and conclusion. An in-progress run has no conclusion yet. That record supports a status update, while a passing conclusion from a different commit cannot settle the question. GitHub check-run fields
Which check result can enter the call?
ExampleAuthorization permits the read. The result applies only if it comes from the requested check on the requested commit.
Read the diagram as text
- Check repository and run access.
- Withhold record.
- Match check and head_sha. Look up the requested check, then verify its run’s commit.
- Seek requested check on requested commit. Leave its outcome unknown if the run cannot be obtained.
- Validate complete input. Keep run ID, status, conclusion if available, and the originating call association.
- Send assembled request.
- Revise request.
- Check repository and run access → Withhold record: Permission denied.
- Check repository and run access → Match check and head_sha: Permission granted for lookup.
- Match check and head_sha → Seek requested check on requested commit: Different check or commit.
- Match check and head_sha → Validate complete input: Check and commit match.
- Validate complete input → Send assembled request: Coverage, pairing, and budget pass.
- Validate complete input → Revise request: A required check fails.
In an OpenAI Responses integration, the application can return those fields as a function_call_output with the originating call_id. Two lookups may finish in reverse order. Pairing by ID keeps each observation attached to the right question. Before sending the request, check the result pairs, the evidence needed to answer, and the room left for generation. Each check can fail independently. Tool definitions · Calls and results
Development and constraints
How context management developed
Dialogue researchers were separating the state of a task from its transcript well before modern language models. In the TRINDIKIT research of 1999–2000, GoDiS maintained shared beliefs, questions under discussion, plans, and immediate obligations. When a traveler supplied a new requirement, update rules could change the plan. Selection rules then determined which question to ask. The useful result of hearing an utterance was a change in what the system still needed to find out. Information states and dialogue move engines
An officeholder can change after a model is trained. In 2020, Patrick Lewis and colleagues used retrieval-augmented generation (RAG) to answer questions using passages retrieved from Wikipedia. When they swapped in a different Wikipedia snapshot, some answers about officeholders changed even though the model generating the answers stayed fixed. ReAct, introduced in 2022, showed how to gather evidence as a task unfolded. On its Wikipedia tasks, the model could request a search, read the result in its next input, and use what it found to decide where to look next. Original RAG paper · Retrieval-Augmented Generation · ReAct
In 2023, MemGPT gave a model operations for editing its working context and reading from larger external stores. The same year, Lost in the Middle examined a different constraint. Even with the answer-bearing document already in the input, moving it among distractors changed accuracy for several models. A larger window could admit more documents, external storage could keep documents available for another read, and neither settled how well a model used a particular passage. MemGPT · Lost in the Middle · Eugene Yan’s contemporary explanation
The April and June 2025 accounts brought these concerns together at the boundary of a single call. On June 25, Andrej Karpathy endorsed the term context engineering for choosing the information needed for the next step. On June 27, Simon Willison explained its appeal as a name for work whose complexity was easy to miss in the phrase prompt engineering. The practices they described already had distinct histories in dialogue management, retrieval, and tool use. Karpathy’s account · Willison’s commentary
Budgeting capacity and effective use
A context budget divides the available capacity between the complete input and the tokens the model may generate. Count the request as rendered for the intended endpoint, including instructions, tool definitions, message formatting, and selected evidence. Reserve room for visible output and, where applicable, reasoning tokens within the same generation allowance. The endpoint may also impose a separate output limit. Count the complete request · Reserve room for generation
For example, an 8,000-token window with 1,000 reserved permits 7,000 tokens of input. If the assembled request already uses 6,800, only 200 remain for an 800-token appendix. For a decision governed by one clause in the appendix, carry that clause and its qualifications. For a call deciding which document to open, its title and reference may suffice. If the required evidence still exceeds the budget, narrow the question or split the work before sending the request. Count again after changing the representation and leave margin when the provider returns an estimate. Claude token-counting contract
Fit is an arithmetic test. Effective use depends on the work. In RULER’s variable-tracking task, one assignment refers to another variable whose value is defined elsewhere. Finding the first variable leaves the answer unresolved until the model follows the assignments to the final value. A workload with comparable dependencies needs a test of the entire chain at its intended length and level of distraction. RULER · Transformers and Attention
Selection and disclosure
Selecting sufficient information
First check which records the requester may use for this task. Among those eligible records, a relevant one helps answer the question. A set of records is sufficient when the answer follows from what they say. Retrieving the general rule several times adds no support for a decision that turns on an exception, even if the exception was mentioned much earlier. A sufficient set can still lead to a wrong answer if one of its sources is wrong. Sufficient Context
| Candidate | What it establishes | What to include or acquire |
|---|---|---|
| Two copies of the general rule | Tests are required. | Keep one after checking that wording and scope agree. |
| Shared-interface exception | This patch also needs owner approval. | Retain the clause and identify the applicable owner. |
| Passing test for this revision | The test condition is met. | Include the result and revision. Detailed logs can wait. |
| Review requested from the owner | The request was sent. | Look up the decision for this revision. Approval remains unconfirmed. |
A ranking can choose among acquired records. If those records omit the owner’s decision, another arrangement of them cannot supply it. A follow-up search now has a precise target. Conversely, when the decision and all its conditions are already present, an unconditional search can add plausible but inapplicable examples. Reranking a fixed set · Leonie Monigatti on follow-up searches
Preserving meaning in representation
Use an excerpt when exact wording controls the decision. Use fields when a reader must associate a value with a unit, object, or revision. A short observation can work if it preserves the scope of the claim. For instance, compare head_sha = <requested commit>, status = completed, conclusion = neutral with the rendering check completed. Both describe the lifecycle state in GitHub’s published example. Only the first identifies the commit and distinguishes a neutral conclusion from a pass. The shortened version might answer whether the run is over while leaving a merge decision unsupported.
Arrange material so a qualification stays with its claim and a result stays with its originating call. Preserve message roles when rendering those associations. To isolate an ordering effect, move the intact passage among the same distractors without changing its wording or the question. In Lost in the Middle, several tested models did better when an answer-bearing document appeared near an end. Results varied by task and model, so repeat the comparison on the decisions your system actually makes. Chat templates and roles · Testing order and formatting
Representation also affects the cost of recovering detail. A study of agents reading database schemas found that a compact file could generate more runtime tokens if a search returned dense lines containing many fields. Compare formats using the actual reads and the resulting answers. File size alone misses the work required to locate the right field. File-schema study
Revealing detail on demand
Progressive disclosure gives the model enough information to recognize a resource, then supplies detail when the task needs it. In Ajay Prakash’s LinkedIn slide, the request is to compute daily active feed users for the previous week with Airflow. An Airflow DAG is a directed acyclic graph describing tasks and their dependencies. Look at airflow_dag_authoring beside code_search. Search can find an existing workflow. The playbook returns LinkedIn’s procedure for setting up the environment, authoring the DAG, and validating it. The neighboring feature_flag_cleanup description is enough to rule that procedure out. The Model Context Protocol (MCP) makes these capabilities available. Requesting the authoring playbook supplies its instructions for the next call. Prakash’s talk · Model Context Protocol

What gets deferred matters. In the Agent Skills specification, the name and description support discovery, activation loads the instructions, and referenced files supply specialized detail. In Anthropic’s tool-search design, the application registers tools and can defer their full definitions until a search identifies them. Frequently used definitions can stay in the initial input. For a small catalog, another search may cost more time than direct inclusion saves. Agent Skills specification · Agent Skills · Tool-search design
Reading beyond a preview
ExampleA visible reference can lead to a complete match, a partial read, or unavailable evidence.
Read the diagram as text
- Preview and result reference.
- Authorize requested read.
- Resolve and search result.
- Detail unavailable.
- Complete matching range. The result covers the requested range.
- Partial range and line numbers. Use the truncation marker and line numbers to narrow the next read.
- Preview and result reference → Authorize requested read: Request omitted detail.
- Authorize requested read → Detail unavailable: Access denied.
- Authorize requested read → Resolve and search result: Read permitted.
- Resolve and search result → Detail unavailable: Entry evicted.
- Resolve and search result → Complete matching range: Requested match fits.
- Resolve and search result → Partial range and line numbers: Match exceeds result limit.
Deferring an existing tool result introduces a storage dependency. Strands’ Context Offloader can replace a large result with a preview and a reference. The retrieval tool searches the saved result and returns numbered lines. If a match is truncated, those lines guide a narrower read. If the entry was evicted, the reference cannot recover it. Check current permission at expansion and identify which portion was returned. For a historical question, running the original query again against live data may return a different value. Context Offloader
The value of a discovery layer depends on how well the agent could already navigate. A 2026 study compared raw-file search with staged access to the same books. Codex already searched a single raw book effectively. For English question answering on larger collections, showing book descriptions first and the selected book’s chunk index later helped more consistently. An application can test that choice by measuring missed discoveries and follow-up reads alongside answer quality. Controlled reading study
Maintenance and continuity
Refreshing and superseding context
An observation has several relevant times. The source changed at one time, the application read it at another, and a summary may have been written later still. The question determines the period that matters. An order’s status at intake may be exactly the evidence an auditor needs tomorrow. Preserve the intake snapshot if the live service exposes only current values. For a question about the order now, obtain a sufficiently current reading. Supersession leaves the earlier status meaningful for the period when it applied. A correction means the earlier report was wrong even then. W3C provenance model
A change of source version, task revision, elapsed time, or access rights may require another check. HTTP caching supplies one precise example. When a response governed by must-revalidate becomes stale, a disconnected cache must return an error rather than reuse it. An application decides separately how recent business evidence must be. Check compatibility as well as age when combining observations. Under PostgreSQL Read Committed isolation, two reads can see different committed states within one transaction. Two recent observations may therefore describe different versions of the world. HTTP caching · PostgreSQL transaction isolation
One order, two status observations
ExampleShipment changes the status premise of a case summary. The support note still supplies the reason for the inquiry.
The order observation supplies a status. The support note explains why it matters.
Read the diagram as text
- Order record. Both reads address this order.
- Support note. The customer asked for the order status.
- Earlier read · processing.
- First case summary. Records the reason for the inquiry and the status at the first read.
- Later read · shipped.
- Status claim under review. The earlier observation still describes what the first read returned.
- Checked replacement. Uses the applicable note and the later status.
- Next model input.
- Order record → Earlier read · processing: First read.
- Earlier read · processing → First case summary: Observed status.
- Support note → First case summary: Reason for inquiry.
- Order record → Later read · shipped: Read after shipment.
- Later read · shipped → Status claim under review: Status changed.
- First case summary → Status claim under review: Contains earlier status.
- Status claim under review → Checked replacement: Replace affected claim.
- Later read · shipped → Checked replacement: Verified status.
- Support note → Checked replacement: Still-applicable inquiry.
- Checked replacement → Next model input: Selected current account.
- Summarize the inquiry. The order observation supplies a status. The support note explains why it matters. Active: Order record, Support note, Earlier read · processing, First case summary. New: Order record, Support note, Earlier read · processing, First case summary.
- Observe a status change. The new read makes the first summary’s status unsuitable for a current answer. Active: Order record, Support note, Earlier read · processing, First case summary, Later read · shipped, Status claim under review. New: Later read · shipped, Status claim under review.
- Rebuild the current account. The checked replacement carries the new status and the original reason for the inquiry into the next call. Active: Order record, Support note, Earlier read · processing, First case summary, Later read · shipped, Status claim under review, Checked replacement, Next model input. New: Checked replacement, Next model input.
In the illustrated rebuilding policy, a support note supplies the reason for an inquiry and an order record supplies the status. After shipment, only the status premise changes. A context builder can follow the summary’s dependencies, verify access, and combine the new observation with the still-applicable note. This requires explicit handling of derived text. Zep, for example, documents that deleting an episode can leave information in a shared node’s summary because deletion does not regenerate the summary. Zep deletion behavior · Search freshness and deletion · Privacy and Data Governance
Keeping instructions and data distinct
A system instruction gives behavioral guidance through an endpoint’s privileged instruction interface. Role and authority come from the message structure and the endpoint’s rules. In OpenAI’s December 2025 Model Spec, higher-authority instructions govern conflicts and tool outputs have no instruction authority by default. A business service may be authoritative about the status of its own orders. Text inside an order record cannot confer permission to send the customer’s data elsewhere. OpenAI Model Spec
Indirect prompt injection occurs when externally supplied content contains instructions intended to redirect the model. Consider two renderings of a retrieved page: The page requests a transfer and Transfer the data. Removing the speaker turns a report into an apparent directive. Preserve the external source and its trust status when quoting, shortening, or handing off the passage. Labels guide interpretation. Trusted application code must still enforce who can read the record, where data may go, and which operation may run. Check access before disclosure and permission again at the proposed effect. Original injection research · AI Security · Authorization at the protected operation
Compacting accumulated information
Compaction reduces the contribution of accumulated history to subsequent calls. Choose what to replace according to what later work may require. Drop a superseded observation when its historical value is irrelevant. Mask bulky tool output with a placeholder to preserve the surrounding action sequence. Keep a sliding window for recent exchanges when earlier turns can safely leave. If one older constraint still governs the task, copy its exact clause or extract it into task state before trimming. A recoverable reference offers another option when the relevant detail cannot yet be predicted.
For the shared-interface patch, an extractive reduction copies shared-interface changes require owner approval. A task record can additionally preserve tests passed, review requested, approval unknown with links to the revision and review. An abstractive summary writes a new account in its own words. Patch tested and ready is fluent but loses the prerequisite. Before substituting a summary, check the goal, conditions, decisions and rationale, unfinished work, attribution, and unknown outcomes against their sources. A subsequent summary based only on that shortened account can perpetuate its omission. Updating the input for the next call is a separate operation from consolidating persistent memories. FRANK’s study of summary errors · Memory consolidation
Provider-managed compaction
In Anthropic’s documented Claude beta, crossing an input threshold triggers an additional sampling step that produces a summary block. On subsequent requests, content preceding the block drops out of processing. OpenAI’s Responses API can instead emit an opaque encrypted compaction item. Applications chaining input arrays retain the returned items according to that API’s contract. Chaining by previous_response_id follows different rules. With an opaque item, a follow-up question that requires an earlier fact can test a property that inspecting the item cannot reveal. Claude compaction · OpenAI compaction
Cost and completed work
| History policy | Mean cost per task | Tasks solved |
|---|---|---|
| Full history | $0.41 | 32.8% |
| Mask older tool observations | $0.18 | 35.6% |
| Summarize older turns | $0.24 | 36.0% |
Masking had the lowest mean cost in that configuration. With the thinking Gemini configuration, both managed policies reduced the solve rate relative to full history. Provider charges can also change the comparison. Prompt caching reuses computation for a matching prefix of a request. Rewriting a cached prefix can forfeit reuse, and generating a summary incurs work of its own. When a fixed procedure qualifies for caching, placing it before changing observations can preserve reuse as the selected records change. Observation-masking study · Prompt caching · Inference Engineering
Reconstructing the next call
After an interruption, build the next input around the current task revision. Recover the objective, standing constraints, accepted results, and unresolved obligations. Include a recent correction if it changes which plan applies. Reopen exact evidence for a historical claim and refresh mutable evidence for a present-tense one. A handoff document can identify both kinds of work, provided it distinguishes a plan from an attempt and an attempt from an observed outcome.
In Anthropic’s coding experiments, feature_list.json recorded the expected behavior and verification steps. A progress file described the preceding session’s work, while Git history located the changes. A fresh session could start the environment, smoke-test the checkout, and select an unfinished feature. The workflow called for setting a feature’s passing flag after testing. A flag in a handoff is therefore a claim whose basis another session can inspect. The applicable checkout and the behavior exercised by the test determine what it establishes. Engineering report · Ash Prabaker and Andrew Wilson’s workshop
For a remote operation that timed out, retain the operation identifier and mark the outcome unknown. The service might have completed its work after the caller stopped waiting. Check current permission and query the authoritative status before treating the action as complete or attempting it again. Restoring this distinction is the context builder’s job. Restarting execution and choosing the next action have their own contracts. Recovering an unknown effect · Agent Runtimes and Harness Engineering · Agent Engineering
Evidence and applications
Testing context policies
Test the builder before grading a model response. Give it a known requester, task, revision, and budget. Assert which records enter, which must be withheld, whether a required clause survives rendering, and whether each result matches its originating call. Exercise a wrong revision, a failed lookup, an expired reference, and a retrieved passage containing an instruction. To test compaction, supply enough history to trigger it and record whether it ran. A correct answer before the trigger tells you nothing about the replacement history.
| What inspection establishes | Where to investigate |
|---|---|
| The acquired records never contained the fact. | Inspect the source, query scope, access decision, and lookup outcome. |
| An eligible candidate contained the fact. The builder omitted it. | Inspect filtering, allocation, and whether the promised follow-up read occurred. |
| The selected clause included a condition. Its replacement summary dropped it. | Repair the transformation and test whether the condition survives substitution. |
| The fact reached the model intact. The answer ignored it. | Hold the question fixed and vary order or distractors to test use. |
| The recorded input is truncated before the relevant passage. | Establish what was captured before attributing the loss to the builder. |
Protect the evidence used for diagnosis. OpenTelemetry’s developing GenAI guidance recommends opt-in content capture because model inputs and outputs may be large or sensitive. A structurally valid logged message can contain shortened text. Mark that limitation or retain an access-controlled reference for exact comparisons. Observability
Testing a continuation
For a behavioral comparison, change the context policy while holding the tasks, initial state, model, tools, budgets, and grading fixed. Include full history as a baseline where it fits. Reset state between independent trials and reserve unseen continuations for the final comparison. Record whether the task succeeded, additional reads, input and cached tokens, time to first token, total latency, and cost through completion. These measures distinguish a cheaper first request from a cheaper completed task. Evals and Benchmarks
In July 2026, the Towards AI tutor team independently varied two choices on DeepSeek-V4-Flash. One capped tool output when it first entered history. The other summarized accumulated history. Five scripted sessions planted student facts early and asked for them later. Three trials gave 414 turns per configuration. The team reported mean trajectory costs of $0.189 without the cap and $0.117 with a stable cap, both with 87% recall on the planted-fact probes. Summarization increased cost in both cap conditions. A separate judge that saw no history accepted generic answers even when they missed a planted fact. The probe required the tutor to recover something only the prior interaction could supply. Evaluation log · Tutor workshop
Coding work and live service records
Two workflows documented in 2025–2026 illustrate when a retained reference is enough to continue. In HumanLayer’s BAML bug investigation, Horthy rejected an incorrect research document before using the findings to plan an edit. Comparing plans with and without repository research, he judged that the research-informed plan placed the fix more appropriately and followed the repository’s testing conventions. Reviewing the intermediate artifact mattered because its claims would become premises for implementation. Horthy’s BAML account · Complex-codebase talk · Coding Agents
For an order-status question, Intercom’s Fin can collect the order ID, keep it in a temporary workflow attribute, and pass it to an external service through a configured connector. When a customer supplies the ID, Intercom recommends that the service verify the customer’s access to that order. The connector can then expose just the fields Fin needs to answer. If the lookup times out, the order’s status is unknown. If it succeeds, compare Fin’s answer with the returned status to check whether Fin used it. Fin Data connectors · Connector failure handling
| Context decision | Repository investigation | Live order lookup |
|---|---|---|
| Basis for the decision | Inspect the applicable code and the checks for the proposed edit. | Read the permitted order record from its service. |
| What to carry forward | Keep reviewed findings, file references, intended edits, and verification steps. Exploratory output can stay outside the plan. | Carry the selected ID to the lookup and expose the relevant returned fields. Exclude unrelated response data. |
| When to reopen the source | Recheck a finding if the checkout changes or the edit depends on omitted detail. | Fetch again when a current answer requires a newer observation. A timeout leaves status unknown. |
| Basis for resumption | A reviewed plan can preserve decisions and point back to code for confirmation. | The documented workflow can use task attributes and connector reads. Fin’s post-compaction reconstruction policy is undisclosed. |
Reference questions
Frequently asked questions
How does context engineering differ from prompting, RAG, and memory?
Prompting specifies behavior with instructions and examples. Retrieval-augmented generation uses acquired evidence to answer a question. Persistent memory retains information across interactions. Context engineering decides which of those materials reach a particular call, in what form, and when to replace them. Prompt design · Retrieval-Augmented Generation · Agent Memory
Does a larger window remove the need for selection?
A larger window can keep an exact passage available without another read. The passage must still apply to the question, and the model must use it alongside any necessary qualifications or related facts. Test the actual dependency at the intended input length.
Should every tool definition and result be included?
Include frequently needed, compact definitions directly when that avoids an unnecessary search. Occasional definitions can be discoverable. For a bulky result, provide a marked preview and a permitted way to retrieve the omitted portion while the original remains available.
When should history be summarized?
Summarize when a later decision depends on an earlier exchange but can proceed from a shorter account. Keep exact qualifications or references where the wording matters. Remove obsolete observations directly, and test a follow-up that depends on the retained detail.
Can a summary establish that work is complete?
A summary can report completion and point to its basis. Accept the claim when the supporting check covers the requested behavior on the applicable revision. If the record shows only a plan or an attempt, retain verification as unfinished work.
Does leaving a message out delete it?
Leaving a message out changes the input for one call. Checkpoints, external stores, and summaries can still hold the message or information derived from it. Deletion requires operations on the retained copies covered by the request.
Does prompt caching refresh a fact or free window space?
A cache hit reuses computation for an eligible matching prefix. Its tokens still occupy the window. To establish whether a value is current, validate the source under the task’s freshness requirements. Inference Engineering
Do source labels prevent prompt injection?
Source labels preserve attribution and help the model interpret external text. A model can still follow an embedded instruction. Enforce the requester’s read permissions before supplying the data and authorize proposed actions in application code. AI Security
Open questions
When should a model seek one more piece of evidence? A set of consistent records can conceal a missing exception, while unnecessary searches add delay and distractions. A useful stopping policy would recover missing prerequisites on held-out tasks with few extra reads when the initial evidence was sufficient.
How much loss comes specifically from rewriting successive summaries? Long sessions also accumulate more obligations, making failures difficult to attribute. Comparing repeated reductions with a single reduction of the original at the same final budget could isolate changes in attribution, conditions, and unresolved outcomes.
How precisely can an application refresh derived claims after a source or permission changes? One sentence can depend on several records, and unnecessary rebuilding consumes time while missed dependencies can expose obsolete or restricted information. Progress would mean identifying affected claims, checking their replacements in the next input, and preserving the supported remainder.








































































































































































































































































































































































































































































































































































































































































































































































