I stopped trusting provider sessions

One N17Q run could resume only while its provider session still existed.

The local database stored a conversation identifier and the latest status. Plans, tool observations, and partial context lived mainly behind the provider API. When I deleted the experiment account data, the run still appeared in the interface and could no longer explain or continue itself.

I had made the provider session the real checkpoint and my own state a bookmark.

A durable agent run needs enough product state to resume when the model, process, or provider changes.

1. Seal

   Commit a coherent checkpoint

   Preserve task state, artifacts, open effects, approvals, policy context, and remaining budgets at one trace revision.

2. Compile

   Build the next context deliberately

   Select a bounded narrative and evidence projections for the next model without promoting the summary to product truth.

3. Resume

   Continue under current authority

   Reconcile unresolved effects and re-evaluate policy before allowing the next consequential action.

Native continuation remained useful

Provider-managed sessions could preserve model context efficiently and support native response continuation. I did not discard them.

N17Q stored the provider session and response identities as adapter observations. If current policy, retention, and compatibility allowed, resume could use that path.

The product never treated its availability as the only path. A native session could expire, be deleted, change semantics, or remain opaque to evaluation.

Convenience became one resume strategy rather than the definition of continuity.

The checkpoint described semantic state

At meaningful boundaries, N17Q committed a versioned checkpoint containing task and target, active plan, selected evidence, constraints, tool registry snapshot, unresolved requests and effects, approvals, world references, artifact digests, policy context, budgets, and configuration.

It did not attempt to serialize a model's hidden reasoning. It retained the observable state needed for another decision step.

The checkpoint linked to semantic events and raw artifacts rather than copying every payload.

Resume began from what the product knew and owned.

Creation was atomic with the trace

A checkpoint that referenced an uncommitted tool observation could restore an impossible state. N17Q wrote checkpoint identity and event boundary in one local transaction.

Large artifacts already existed by digest or remained pending outside the checkpoint. An incomplete artifact prevented the checkpoint from claiming it.

If the process failed after a remote effect but before local observation, recovery returned to the prior checkpoint with an in-flight attempt and used receipts or query semantics. It never advanced based on a half-written summary.

Durability began with a coherent cut through the run.

The most important checkpoint field was often the least pleasant: an external attempt might have happened and was not yet reconciled.

N17Q stored effect intent, attempts, strongest known stage, idempotency and query contract, receipts, allowed recovery, and prohibited repetition. A new provider context received this state explicitly.

The final policy gate also loaded it independently. Even a bad resume summary could not authorize a duplicate effect.

A checkpoint that forgot uncertainty was not resumable; it was dangerous amnesia.

Tool identity survived catalogue changes

The run recorded the registry snapshot and mapping revision used by every request. Current eligible tools could differ at resume.

N17Q preserved historical tool events and built the new offered set under current policy. An unresolved intent pinned its old effect contract for interpretation and could require migration before recovery.

A similarly named server tool did not inherit the old mapping. A removed capability could remain in history without becoming executable.

Continuity separated what happened from what remained possible.

Each provider adapter received a generation plan with current goal, bounded event narrative, required constraints, evidence excerpts, world state, budgets, and offered capabilities.

The compiler produced a manifest of included, omitted, summarized, and transformed material. Required safety state could not be dropped merely to fit a smaller context window.

Different providers could receive different representations of the same semantic checkpoint. The run recorded which one each attempt saw.

Portability meant stable meaning, not identical token sequences.

Summaries remained derived artifacts

A readable handoff helped the next model and the human reviewer. N17Q generated it from structured state and event ranges, then validated mandatory facts.

The summary carried compiler and model identity. Regeneration created a new artifact. It could be corrected without rewriting the source events.

If it called an unknown effect failed, omitted a denial, or presented expired approval as active, the checkpoint remained valid and the summary did not.

Narrative improved orientation without owning authority.

Resuming with another model did not pretend one deterministic agent had continued uninterrupted. N17Q appended a configuration-transition event naming old and new provider, model, adapter, reason, checkpoint, and context manifest.

The run identity stayed stable because the task history remained one chain. Segment identity enabled evaluation of behavior under each configuration.

Scenario policy could prohibit a change for controlled replay or require review for sensitive work.

Continuity could acknowledge a different decision-maker configuration.

One adapter supported native continuation, another needed reconstructed input, and another had a smaller context or weaker structured output.

The capability profile guided compilation and eligibility. A fallback that changed data handling, tool availability, or retention required an explicit routing decision.

N17Q did not call every path resume() and hide whether it was continuing a provider object or starting a fresh attempt from a product checkpoint.

The UI used resume run and continue provider response as related but distinct states.

Policy was re-established

A checkpoint preserved historical policy and decisions. The next action ran under current policy, requester authority, delegation, tool mappings, budgets, and world state.

Old approvals could be expired, revoked, or stale. New restrictions could stop an intended action. The trace retained the original configuration without granting it immunity.

Resume was not restoration of all former permission. It restored knowledge and intention, then asked what remained allowed.

Long-running state survived; authority stayed current.

Starting a new provider session could look like a new billing context. N17Q retained cumulative run usage and reservations across it.

The next model saw remaining relevant budget. The final gate enforced durable counters. Provider-reported usage from each segment stayed in its native dimensions and reconciled into product accounting.

Changing providers could alter cost estimates and context capacity without refunding the resources already spent.

A checkpoint was continuation, not a loophole into a fresh allowance.

For coding scenarios, the checkpoint referenced immutable base, current overlay snapshot, repository tree digest, uncommitted changes, commands, and validation artifacts.

A new sandbox reconstructed that controlled state rather than cloning the latest default branch. If the required environment or dependency snapshot was unavailable, resume failed visibly or prepared a migration.

External workspace changes became new input and conflict, not silent replacement.

The provider session had never been sufficient to restore files anyway.

Approvals survived as evidence, not portable power

The checkpoint retained what a person reviewed and decided. A new adapter or process could display that record.

Execution still verified exact effect intent, normalized digest, policy, expiry, reviewer authority, tool mapping, and preconditions. A changed context did not automatically invalidate identical approval, and a changed consequence could not inherit it.

Historical consent remained understandable while current capability stayed bounded.

Portability did not turn receipts into bearer tokens.

Giving work to another configured agent role was a specialized resume from a checkpoint. The role received only relevant state and its eligible tools.

Research evidence could cross to a repository role without transferring research credentials. An unresolved external effect crossed because every role needed to avoid duplicating it.

The handoff event named source, destination, context manifest, and responsibility change.

One durable checkpoint architecture supported process restart, model switch, and role transition without making them identical.

Human continuation remained complete

An author could open the checkpoint without any model provider. The interface showed task, current workspace or document, evidence, pending approvals, unknown effects, budgets, and safe next actions.

Manual edits, review, export, rejection, and effect reconciliation remained possible according to policy. A harness-generated summary could explain the state if no final model response existed.

This was the strongest ownership test. Provider absence reduced generation and did not make the work unknowable.

The run could end in human hands.

Artifact retention made limits explicit

Some raw provider payloads or source excerpts could expire before the semantic checkpoint. N17Q retained safe identity, digest, classification, and tombstone.

Resume could proceed only if required evidence remained available or could be retrieved under current policy. It did not reconstruct missing content from a summary and call it original.

The interface explained degraded checkpoints. Archival profiles could retain more under deliberate policy.

Durability was honest about what deletion removed.

Schema migration preserved old meaning

Checkpoint fields evolved as N17Q learned about effects, budgets, and policy. Readers supported old versions through explicit migrations.

Structural migrations produced a new derived checkpoint and kept the original. Meaning that could not be inferred became unknown or required review; it was never filled with a convenient default.

Fixture runs opened checkpoints from earlier versions and verified denials, effects, and budgets survived.

Portable state needed the same backward discipline as any long-lived data format.

Saving after every token produced noise and saving only at final response lost too much work. N17Q checkpointed after accepted model output, tool observation, policy or approval decision, world reconciliation, meaningful workspace mutation, and run-state transition.

Long commands could emit progress artifacts without advancing resumable semantic state. A checkpoint interval guard limited loss during quiet local analysis, but it never claimed an incomplete operation had committed.

The frequency followed decisions another process could safely continue from.

Rate limits, approval waits, delayed retries, and recovery checks could outlive one model response. The checkpoint named scheduled intent, next eligibility, governing clock, reservation, and cancellation conditions.

The scheduler reconstructed this state from durable records. It did not rely on a provider session staying active or a client tab setting a timer.

When the time arrived, policy evaluated again. The schedule was an intention to reconsider, not deferred permission to execute.

Source retrieval remained reproducible

The provider context might contain a quoted web or file-search result that no local record preserved. Resuming elsewhere would either lose it or search a changed world.

N17Q checkpointed approved source observations with identity, retrieval time, content digest, safe excerpt, scope, and fixture strategy. Live results followed retention policy; replay used reviewed recordings.

If a required source could not be retained, the checkpoint described the gap and required current retrieval before relying on it. A model summary did not become the source.

Repositories, images, command logs, and provider streams could make a literal snapshot enormous. The checkpoint stored content-addressed references and small structured projections.

Garbage collection followed reachability from retained runs and policy. Protected receipts and unresolved-effect evidence could not be removed as cache. Read paths verified artifact digests and reported degraded state.

This kept checkpoint commits quick without making durability depend on mutable file paths or accidental caches.

Security review treated resume as input handling

Checkpoint packages could be tampered with, imported from another environment, or contain hostile text. N17Q validated schema, digests, run ownership, artifact classifications, allowed adapter mappings, and environment compatibility before opening one.

Import never restored credentials or activated tools. Text remained untrusted context. Current policy built the offered catalogue from local configuration.

A portable checkpoint carried work state, not executable authority.

Partial corruption stopped narrowly

If one optional raw provider artifact was missing, the run could remain inspectable with degraded diagnostics. If the current workspace snapshot, unresolved effect record, or policy identity was missing, resume stopped.

The manifest classified required and optional components. Repair appended evidence or created a migrated checkpoint; it did not silently substitute nearest files.

This made failure proportional and prevented a corrupted convenience artifact from destroying the whole archive.

Owner notes were durable and separate

A person could add a handoff note explaining an intention not captured by mechanical state. It received author identity, checkpoint, visibility, and revision.

The context compiler could include it, but the note could not grant tools or alter receipts. Another person could correct it through a new note while the original remained.

Human context enriched continuation under the same boundary as model summaries: useful narrative beside authoritative product state.

Checkpoint manifests carried digests for semantic event boundary, artifacts, workspace snapshot, tool registry, policy, and context summaries.

Verification detected missing or altered components before resume. Digests established identity, not truth. World receipts and evaluator assertions still determined whether the recorded outcome was correct.

An optional signed archive could provide stronger tamper evidence under a managed key. The product did not describe a checksum as authorship.

Resume began only from internally coherent evidence.

Branching created a child run

Trying another model or policy from an old checkpoint could be continuation or counterfactual experiment. N17Q distinguished them.

A normal resume extended the same run under current configuration transition. A counterfactual created a child run with a separate simulated world and named controlled difference.

Both referenced the checkpoint. Neither rewrote events before it. Effects in a branch never crossed into the original world.

Shared state did not imply shared history after divergence.

Native and semantic traces could disagree

The provider session sometimes contained a tool message the local adapter had rejected before semantic commit. Native continuation might remember it; the product run did not treat it as executed.

The context compiler clarified current product state and available tools. The final gate ignored provider memory as authority. The trace linked the disagreement for diagnostics.

Where native state created unacceptable ambiguity, N17Q started a fresh provider attempt from the checkpoint instead of continuing it.

Session fidelity was less important than product-state fidelity.

Fixtures checkpointed after a tool observation, approval wait, unknown effect, partial repository edit, budget warning, and model response interruption. Tests then killed the process, removed provider session, changed model adapter, or changed current policy.

The run had to reconstruct understandable state, preserve uncertainty, retain counters, and apply current authority. External effects could not repeat. Missing required artifacts stopped with a precise result.

Testing only clean provider continuation would have missed the purpose of the checkpoint.

Export made the boundary inspectable

A safe checkpoint package included semantic state, event range, artifact manifest, workspace snapshot references, tool contracts, policy identity, budgets, context manifests, and a human README.

It excluded credentials and did not enable live tools. Another compatible harness could inspect or replay fixtures offline. A human could recover current work with ordinary files.

Provider-specific diagnostic artifacts were optional and clearly labelled.

Portability turned architectural claims into a folder I could open elsewhere.

After the redesign, I repeated the original experiment: checkpointed, removed the provider-side session, disabled the adapter, and reopened N17Q.

Native continuation was unavailable. The task, evidence, tool history, world state, unknown effects, budget, and workspace remained coherent. I could resume with another eligible model or continue manually.

The new attempt knew it was reconstructed. The trace kept the transition.

The experiment also exposed one provider-specific field that had leaked into local plan state. I moved it into adapter provenance and stored the corresponding product concept explicitly. Portability was not achieved by ignoring differences; it came from assigning each difference to the layer that could own it.

The session became what it should have been

A provider session is a useful execution artifact. It can make continuation efficient and preserve provider-specific context. It should not be the only place a product remembers its work.

N17Q's checkpoint belonged to the run: semantic events, artifacts, constraints, policy, effects, approvals, world state, and budgets under stable local identity. Provider state attached to it and could disappear.

This added storage and compilers. It removed a more serious dependency—the idea that long-running work existed only as long as one remote conversation did.

The model could change. The process could end. The session could vanish.

The work still knew where it was.

That made continuation a property of N17Q rather than a favor borrowed from one provider’s retained memory.