The context ended; the work did not

I kept an N17Q task alive by keeping its conversation alive.

Every tool result, denial, plan, patch, and correction remained in one provider session. When the context grew too large, I summarized older turns and continued. The run felt durable until the session expired and the summary omitted an unknown external effect.

Long context had postponed state design. It had not replaced it.

A long-running task needs a durable record of work, authority, and uncertainty that can generate context for the next step.

Context is a view for one decision

A model request needs enough task, evidence, constraints, tools, and current state to choose the next output. It does not need to become the sole archive.

N17Q treated every provider input as a compiled view with a manifest. The run persisted semantic events and artifacts independently.

When the decision ended, the context could disappear. Its manifest remained evidence about what the model had seen.

This reduced pressure to make one prompt carry the entire life of the task.

Run, task revision, configuration segment, turn, tool request, effect intent, execution attempt, checkpoint, workspace, artifact, and receipt had local identities.

Provider conversation and response IDs attached as observations. They could support native continuation without becoming foreign keys for product truth.

Switching models or losing a session changed configuration and not the history of the work.

Identity made continuation portable across execution surfaces.

N17Q appended model output observed, plan proposed, tool requested, policy decided, approval decided, tool attempted, effect observed, artifact stored, checkpoint created, run paused, resumed, and stopped.

Raw streams and logs remained linked diagnostics. Projections built current state from meaningful events.

A later correction appended another event. It did not edit the past into a cleaner story.

Durability began with a record designed for recovery rather than transcript display.

Repository snapshots, diffs, source files, screenshots, command output, model payloads, and evaluation reports lived in content-addressed storage.

Events referenced digest, media type, role, retention, and creator. Checkpoints remained small enough to commit quickly.

Missing artifacts degraded or blocked resume according to their semantic requirement. Mutable local paths never served as the only reference.

Large context became linked evidence, not copied text.

A checkpoint named the event boundary and structured state another process could continue: goal, active plan, constraints, evidence, workspace, tool registry, unresolved requests and effects, approvals, policy, budgets, scheduled work, and configuration.

Creation committed atomically with its boundary. Incomplete external observations stayed unresolved instead of being rounded into success or failure.

The checkpoint did not serialize hidden reasoning. It preserved observable facts and decisions.

Resume started from a state the product could explain.

Unknown outcomes were durable

A provider session could forget that a timeout occurred after an effect might have committed. N17Q's effect registry could not.

The checkpoint retained intent, attempts, strongest known stage, idempotency and query contract, receipts, prohibited repetition, and safe recovery.

The next context included the relevant summary. The final policy gate loaded the structure directly.

Uncertainty survived process and model boundaries until evidence resolved it.

A user message saying yes was insufficient as durable authority. N17Q stored exact prepared object, normalized consequence, policy, checkpoint, reviewer, expiry, and consumption state.

Resume could display the historical decision. Execution rechecked current eligibility and world preconditions. A new model could not interpret an old affirmative sentence broadly.

Approval remained evidence and bounded capability outside conversational memory.

The task could continue without floating consent.

Starting another provider response or worker did not reset model, tool, effect, compute, time, artifact, or review counters.

N17Q charged a durable run ledger and reserved capacity for concurrent work. Recovery kept protected status-query and teardown allowance.

The next context received remaining relevant budget. Policy enforced it independently.

Process lifecycle never became a loophole around cumulative limits.

Rate limits, approval waits, delayed status checks, and retry eligibility could outlive a process. N17Q stored semantic intent, next consideration time, governing clock, reservation, and cancellation condition.

The scheduler re-enqueued evaluation, not guaranteed execution. Current policy and world state ran again.

No browser timer or provider session had to remain awake.

Waiting became state rather than suspended memory.

For code tasks, checkpoints referenced immutable base, initial overlay, current tree, environment, instructions, commands, and validation receipts.

A new sandbox reconstructed that state. It did not clone the latest repository and call it resume. External changes appeared as conflict or explicit rebase input.

Unrelated local work remained protected across restart.

The task's world survived separately from the process that had mounted it.

Run status had more than three values

Long work could be awaiting approval, scheduled, paused by policy, blocked by missing fixture, outcome unknown, budget exhausted, stopped by owner, completed, failed, or superseded.

Each state named allowed transitions. A final model response did not automatically select completed. A stopped run could still satisfy safety and handoff requirements.

Explicit state made resumption predictable and kept ambiguity from hiding inside a generic active flag.

Tool request, semantic effect intent, and execution attempt remained separate. A new worker could continue one intent under the same idempotency identity without erasing the failed attempt.

Leases controlled who worked now and never proved what happened remotely. Unknown outcomes entered reconciliation before another try.

Durable identities converted process failure into workflow state instead of duplicate consequence.

Within N17Q's transaction boundary, policy allow, approval consumption, intent activation, and outbox creation committed together. A worker sent only committed entries.

The remote effect remained outside the transaction. Idempotency, query, receipts, and unknown state handled that gap.

After restart, the outbox and effect registry explained whether work was ready, attempted, or unresolved. No provider context was needed to guess.

Search over traces, artifacts, and repository files improved continuation. If an index became the only place a plan or source existed, it was no longer a projection.

N17Q could rebuild indexes from semantic events and retained artifacts. Index revision entered search observations. Missing index delayed retrieval and did not erase state.

This applied the same ownership test to convenience infrastructure as to provider sessions.

Checkpoints were summarized repeatedly across long scenario families. Tests asserted retention of denials, unknown effects, approvals, evidence identities, local changes, stop conditions, and budgets.

The resumed model's first plan was evaluated for repetition and forbidden consequence. The final gate still contained execution.

A shorter context passed only when the run remained both understandable and governed.

Branches did not merge themselves

Two continuation attempts from one checkpoint could produce different patches or external plans. N17Q gave them child run identities and separate worlds.

Merging artifacts required an explicit new task against a selected target. Approvals and effects did not transfer automatically. The original branches remained.

Long-running experimentation stayed distinct from one authoritative history.

Event, checkpoint, artifact, policy, and tool-contract schemas evolved. N17Q opened old runs through explicit versioned readers and migrations.

Unknown meaning became unknown or blocked resume rather than receiving a convenient default. Original packages remained available for audit. Migrated checkpoints were derived artifacts.

Durable state required maintenance across code releases, not just storage.

Rebuilding an entire run for every turn became slow. N17Q checkpointed projections, content-addressed repeated artifacts, and incrementally updated indexes while preserving rebuildability.

Verification sampled and periodically rebuilt state. A mismatch stopped migration or resume. Optimization did not replace the append-only source.

The system could remain responsive without making caches authoritative.

Privacy shaped what could remain

Some source payloads, provider events, or reviewer notes expired sooner than the run. Tombstones preserved safe identity and decision relationships.

A continuation requiring removed content stopped or retrieved it again under current policy. A summary could not reconstruct prohibited text. Exports selected visibility classes deliberately.

Long life increased the importance of finite retention and typed absence.

An archive package included semantic state, manifests, artifacts, world fixtures, instructions, skills, budgets, and a human README. It excluded credentials and live authority.

Restore verified digests, compatibility, and local policy. The run could be inspected offline before any continuation became eligible.

This made disaster recovery and migration concrete rather than depending on a provider's retention promise.

Observability remained useful after completion

A completed run could later receive a corrected effect observation, evaluator revision, or source staleness event. N17Q appended the new evidence and updated current projections.

It did not reopen execution automatically. A person decided whether another task was needed.

Durable state allowed learning after the final answer without rewriting what the run knew at completion.

The next model did not receive every historical event. N17Q selected current goal, constraints, unresolved state, evidence, workspace observations, recent decisions, and available tools.

Required safety fields could not be omitted. Negative evidence and denials stayed where they prevented loops. Older detail remained retrievable through bounded tools.

The compiler produced an inclusion and omission manifest.

Long history supported focused context instead of forcing an impossible choice between all and nothing.

Summaries were replaceable

A human-readable narrative helped orientation and could be wrong. N17Q generated it from semantic state, validated mandatory facts, and attached provenance.

Regeneration created a new artifact. Repeated compaction returned to events and current projections rather than summarizing the previous summary.

Structured state stayed authoritative. The model could challenge a summary with linked evidence.

Continuity did not depend on perfect prose compression.

If a provider failed or a stronger model became eligible, the run appended a configuration transition at a checkpoint.

The new adapter compiled a compatible context and recorded differences in tool representation, limits, and data routing. It never pretended to share hidden state with the old model.

Scenario policy could prohibit changes for controlled replay.

Long work could adapt without losing configuration provenance.

Human handoff used the same state

A person opening the task saw current artifact, completed work, evidence, unknown effects, pending approvals, budget, blockers, and safe next actions.

They could edit manually, supply a source, reconcile an external resource, reject a proposal, or stop. No model response was required to make the handoff legible.

A later agent resumed from the resulting checkpoint with the human intervention attributed correctly.

Durable state supported collaboration across kinds of actor.

A long run might use source research, repository migration, and trace review skills in phases. Keeping every instruction in one permanent context recreated overload.

N17Q recorded skill version, references, requested tools, produced artifact, and unload transition. Downstream phases consumed validated outputs.

An unresolved effect retained its recovery contract even after the originating skill left context.

Expertise could be temporary because the result was durable.

Tool catalogues changed over time

Connections degraded, MCP schemas changed, and policy retired capabilities. The checkpoint preserved historical registry and current eligibility separately.

Resume built a current offered set. Pending intents used pinned semantics for interpretation and could require migration.

A same-named tool did not silently replace an old one.

Long-running state outlived integrations without ignoring their changes.

The run stored historical decisions and never froze authority. Every execution boundary loaded current requester, delegation, policy, approval, budget, mapping, effects, and world preconditions.

A policy update could stop an old plan. The trace retained when and why.

Restoring a checkpoint restored knowledge and intention, not every former permission.

Durability did not become immunity from the present.

Replay used the checkpoint, not a conversation export

A scenario package contained controlled world, fixtures, environment, tool contracts, policy, and checkpoint. It excluded live credentials and provider sessions.

Replay reconstructed observations and effects inside simulation. Missing fixtures failed closed. Counterfactual branches received new identities.

Conversation text could remain a diagnostic artifact. The semantic checkpoint defined what the harness could reproduce.

The unit of portability was the run environment and state.

Not every raw token, source excerpt, or command log stayed forever. Retention classified artifacts and preserved tombstones, digests, and semantic outcomes where content expired.

Resume stopped if required evidence was gone. It did not infer missing payloads from a summary. Archival profiles could retain more deliberately.

Deleting the run removed checkpoints, events, artifacts, indexes, fixtures under ownership, and scheduled work through a verified workflow.

Durable never meant immortal by accident.

Checkpoint manifests linked event boundary, artifacts, workspace, registry, policy, summaries, and schema versions by digest.

N17Q verified required components and migration compatibility. Digests established identity, not truth. World receipts and evaluation still mattered.

Optional missing diagnostics produced degraded state. Missing unresolved-effect evidence blocked continuation.

The task resumed only from a coherent package.

Large provider windows could reduce retrieval overhead and preserve nuanced recent discussion. N17Q used them when eligible.

It stopped treating size as durability. The same context manifest could target a smaller model through more retrieval, or a larger one through richer excerpts, without changing product state.

More tokens improved one decision when filled well. They did not guarantee recovery after a crash.

Context capacity and task lifetime stayed separate concerns.

The failure drill killed everything

I checkpointed after a partial test, approval wait, unknown simulated effect, and local patch. Then I terminated the worker, removed provider session, disabled one tool mapping, and advanced policy.

N17Q reopened the run, preserved every awkward state, denied stale execution, reconstructed the workspace, and offered current recovery. A different model could continue or a person could stop.

No single context window survived the drill.

The task did.

N17Q recorded how much recent work a crash could lose, how long state reconstruction took, which artifacts were required, and whether manual intervention remained.

The goal was not zero interruption. It was a bounded, truthful recovery point with no duplicate effects or forgotten constraints. Scenario faults killed workers at each semantic boundary and compared restored state.

Durability became an executable service promise inside the personal project rather than a vague feeling that the chat usually resumed.

Long tasks still needed stop conditions

Durable state could make a bad task continue forever. Every run retained owner stop, policy stop, budget exhaustion, repeated-denial, missing-evidence, and unrecoverable-uncertainty transitions.

Stopping created a final checkpoint and account. Scheduled work and unused approvals were revoked or retired. Unknown external effects remained visible for manual reconciliation.

Persistence served the task; it did not become an excuse to avoid deciding that safe progress had ended.

Moving state out of context could tempt another simplification: if it was stored, it was understood. N17Q still needed schemas, projections, interfaces, retention, migrations, receipts, and tests that preserved meaning.

Durable bytes without a recovery contract would only make confusion permanent. The run model earned its value by supporting inspection, continuation, correction, and deletion.

State design replaced conversational accident with maintained product responsibility.

Durable state makes long work ordinary

A long-running agent does not need one immortal process or endlessly growing conversation. It needs stable identities, semantic events, artifacts, checkpoints, current policy, receipts, budgets, and a compiler that presents the next actor with sufficient context.

This architecture adds machinery. It also makes failure, handoff, model change, replay, deletion, and manual continuation normal states rather than emergencies.

N17Q stopped measuring endurance by how long a chat could remain open.

The work lasted because the product remembered what mattered after the context was gone.

It remembered enough to resume, enough to refuse, enough to explain uncertainty, and enough to let a person close the task without first recreating the conversation that had produced it.

That was endurance with ownership, rather than mere conversational persistence.