Amnesic Process Resets or Persistent Context for Autonomous Coding Agents

The Unattended Execution Problem: Ephemeral Process Resets Versus Stateful Compaction

When you leave an autonomous coding harness running unattended across a thirty-step refactor, the failure you encounter is rarely a failure of raw code synthesis. It is an architectural failure of state retention. The job both stateful and ephemeral harnesses compete to solve is deceptively straightforward: keep an agent grounded in a multi-step engineering task without behavioral drift, looping, or progressive context corruption. How they attempt to achieve that stability, however, represents a fundamental ideological split.

Mainstream autonomous harnesses—ranging from standard conversational setups in Devin to compaction loops in SWE-agent and Aider—treat the agent process as a long-lived interactive thread. In these architectures, dialogue history serves as the primary operational state. As the agent navigates the codebase, runs build scripts, inspects compiler warnings, and discards broken prototypes, every single stdout string and diff chunk appends to the conversation buffer. When that buffer inevitably swells toward capacity, the runtime attempts triage: sliding-window truncation, background summarization, or scratchpad prompts like scratchpad.md to distill prior turns.

The alternative architecture abandons conversational continuity entirely. In an amnesic headless loop, the harness aggressively kills the agent CLI process after every single task or micro-step. There is no conversation history carried over between iterations, no persistent vector store of prior dialogue, and no internal chat memory. State reconstruction is forced strictly onto the filesystem and the git working tree. The incoming process boots cold, reads the repository from disk, executes an isolated edit, writes to the tree, and exits.

My thesis is clear: treating the repository as the primary kernel and the LLM as an ephemeral, disposable processor permanently cures context poisoning, but it shifts immense architectural complexity into the external harness. In my own systems, adopting the viewpoint that the codebase is an environment, not an autoregressive window proved necessary once multi-turn debugging sessions consistently degenerated into hallucinated repair loops. When conversational memory is eliminated, the harness can no longer rely on the model to "remember" its mistakes; the supervisor infrastructure must shoulder the full burden of orchestration, validation, and historical tracking.

quadrantChart
    title Context Lifetime vs State Authority in Autonomous Harnesses
    x-axis Ephemeral Per-Step --> Long-Lived Session
    y-axis In-Dialogue Memory --> Git Working Tree
    quadrant-1 Hybrid Long-Lived Trees
    quadrant-2 Amnesic Process Resets
    quadrant-3 Ephemeral Dialogue Buffers
    quadrant-4 Monolithic Stateful Buffers
    Monolithic Stateful Sessions: [0.88, 0.15]
    Rolling Compaction and Scratchpads: [0.65, 0.42]
    Amnesic Process-Reset Loops: [0.12, 0.88]

Context Integrity Versus the Cold-Start Rediscovery Tax

The immediate payoff of an amnesic loop is pristine attention integrity. In a state-retaining harness, a single npm test failure emitting two thousand lines of stack traces remains pinned in the attention window for subsequent turns. The model's attention degrades: it attends to discarded prototypes, fixates on stale compiler errors already resolved three steps ago, and begins hallucinating changes based on obsolete intermediate states. By terminating the CLI runtime after each discrete modification, the amnesic pattern purges that ephemeral diagnostic cruft completely. Every newly spawned agent instance begins with a clean context window anchored directly to current disk reality.

Yet that pristine attention window carries a steep operational tariff: the cold-start rediscovery tax. A long-lived or compacting session remains warm. It already knows that authentication middleware lives in src/auth/jwt.ts, that dependencies are managed via pnpm workspaces, and that the unit test runner requires a specific environment flag. It does not need to spend wall-clock time or inference tokens re-establishing basic spatial orientation.

In contrast, an amnesic agent booting with zero conversational memory lands in the repository completely blind. Before it can touch a single line of code, it must spend its initial token budget re-running directory listings, inspecting package.json, grepping for symbol definitions, and reading configuration headers. Over fifty micro-steps, the cumulative token burn of repeatedly re-reading identical project manifests often eclipses the token cost of a persistent session. Furthermore, each discovery step introduces wall-clock latency, turning what could have been a snappy localized modification into a multi-turn environmental re-indexing pass.

Evaluation Dimension	Amnesic Process Resets	Stateful Compaction & Scratchpads
Context Decay Risk	Near zero; every step executes with a pristine attention window anchored to disk.	Moderate to severe; summarization loses fine details while stale traces corrupt attention.
Token Overhead per Micro-Step	High; spends tokens on every boot re-inspecting manifests, structure, and entry points.	Low; retains warm navigational context and workspace topology across turns.
Re-grounding Latency	High; cold starts require repeated environment exploration before code edits begin.	Low; immediate action execution from pre-existing conversational understanding.
Resistance to Repetitive Debugging Loops	High for positive state, but vulnerable to cycling unless negative history is logged to disk.	Low; models frequently loop by fixating on invalidated errors preserved in dialogue history.

Compacting architectures like Aider or SWE-agent attempt to split this difference by preserving navigational memory while summarizing out verbose tool outputs. However, lossy conversational compression frequently drops the exact subtle constraint needed to avoid a regression, while still allowing invalidated assumptions to bleed into future prompts. Choosing between these paradigms is ultimately an explicit trade-off between paying token overhead on environmental re-discovery or risking complete task derailment from conversational drift.

Verification Integrity: External Deterministic Supervisors Versus Conversational Self-Reporting

The most insidious operational failure in unattended autonomous coding is hallucinated task completion. In monolithic or chat-centric harnesses, progress tracking is handled conversationally. The agent executes a tool, inspects its own output within the dialogue buffer, and reflexively determines whether its implementation meets requirements. Under expanding context pressure, models routinely fall into self-delusion: they "remember" planning a fix, observe a messy terminal output, and rationalize that a broken assertion is actually an expected edge case or declare TASK COMPLETE while leaving tests broken.

Amnesic architectures prevent this failure mode by enforcing a strict division of labor across execution tiers and external gates. State transitions do not depend on the model's self-assessment; they are mediated entirely by an external supervisor runtime outside the LLM process.

The harness structures execution through a decoupled, two-tier model arrangement:

1. The Mutation Tier: A fast, focused model (such as Claude Sonnet) is launched in a single-shot CLI invocation. Its sole responsibility is inspecting the target files, executing a bounded micro-step edit, and exiting.
2. The Deterministic Gate: Before any reasoning model evaluates the output, the external supervisor runs rigid, non-LLM validation: syntax checks, linters, static type checkers, and unit test suites. If the code fails to compile or breaks a test, the supervisor executes git reset --hard HEAD and terminates the iteration immediately.
3. The Auditor Tier: Only when deterministic checks pass does the supervisor invoke a deeper reasoning model (such as Claude Opus). Crucially, the auditor does not evaluate the mutator's conversational rationale or intermediate thoughts; it audits only the raw git diff against the original user prompt requirements.

sequenceDiagram
    autonumber
    actor Supervisor
    participant Mutator as Mutator CLI (Sonnet)
    participant Workspace as Git Working Tree
    participant Linter as Deterministic Test Runner
    participant Auditor as Auditor Model (Opus)

    Supervisor->>Mutator: Spawn single-shot process with task prompt
    Mutator->>Workspace: Inspect files and apply code edits
    Mutator-->>Supervisor: Process exit
    Supervisor->>Workspace: Collect git diff
    Supervisor->>Linter: Execute typecheck, lint, and unit tests
    alt Tests fail
        Linter-->>Supervisor: Test failures reported
        Supervisor->>Workspace: git reset --hard HEAD
    else Tests pass
        Linter-->>Supervisor: Verification passed
        Supervisor->>Auditor: Submit raw git diff against requirements
        Auditor-->>Supervisor: Approval verdict
        alt Diff approved
            Supervisor->>Workspace: git commit -m 'Apply verified step'
        else Diff rejected
            Supervisor->>Workspace: git reset --hard HEAD
        end
    end
    Supervisor->>Supervisor: Terminate lingering processes and schedule next step

This separation transforms verification from an introspective, subjective dialogue into an out-of-band operational boundary. The mutator never reviews its own work, and the auditor is never exposed to the noisy diagnostic struggles that produced the diff.

Failure-Mode and Effects Analysis: Negative Knowledge Amnesia and Out-of-Band State

When evaluating disposable agent harnesses, standard engineering intuitions about process isolation can obscure subtle runtime failure modes. Decoupling the LLM process from persistent state solves attention pollution, but shifting all operational truth to the filesystem introduces severe failure modes across three distinct boundaries.

Applying a formal Failure Mode and Effects Analysis (FMEA) reveals where clean-slate restarts collapse in unattended environments:

1. Negative Knowledge Amnesia (Severity: High)

The most frequent failure mode in purely amnesic harnesses is diff oscillation. While clearing the context purges distracting compiler spew, purging conversational history also destroys negative knowledge—the explicit memory of which hypotheses failed and why. If Step 3 attempts a refactor using an incompatible configuration flag and fails supervisor verification, the process is terminated and the workspace resets. Step 4 boots with an identical clean slate, inspects the unchanged repository, and naturally arrives at the exact same plausible-sounding, broken fix. Without conversational continuity, the harness falls into ping-pong diffs, thrashing between mutually incompatible syntax choices across sequential micro-steps.

2. State-Diff Blind Spots (Severity: High)

The clean-slate hypothesis assumes that the git tree represents total system state. In practice, operational reality frequently lives out-of-band:

• Orphaned Daemons: If an agent spawns a background service, test runner, or container during its run, killing the primary CLI process does not automatically reap detached background children. The incoming agent boots cold, attempts to run integration tests, and crashes immediately with EADDRINUSE. Because the new process has no memory of launching the daemon, it cannot diagnose why port 3000 is occupied.
• Transient Cache Corruption: Build caches, untracked .env overrides, and altered node_modules binaries sit outside git tracking. If a failed step corrupts an untracked cache, the next agent inherits a broken build environment invisible to git diff.

Mitigating this requires ruthless container-level hygiene: the supervisor must isolate each micro-step inside disposable sandboxes or namespaces, terminating the entire process group upon exit.

3. Micro-Step Atomicity Failures (Severity: Critical)

If an agent attempts a broad refactor and exhausts its execution budget mid-transit, it leaves behind unparseable ASTs and broken syntax. When the next amnesic agent boots, it cannot discern whether the repository is mid-migration or simply corrupt. Lacking conversational intent, it will spend its entire token budget attempting to "repair" half-migrated files back into legacy patterns. The mitigation is strict atomicity: the supervisor must enforce an immediate git reset --hard HEAD whenever a micro-step exits without passing basic syntax and linting checks.

Testing the Clean-Slate Hypothesis: Where Git Working Trees Fall Short

The foundational premise of the amnesic harness is that wiping dialogue memory and treating the git tree as the sole authority guarantees deterministic execution. In my experience, while process resets unquestionably eliminate prompt cruft, the git tree records what changed, but never why an alternative was abandoned.

A git working tree is fundamentally an engine of positive state: it tracks existing lines, staged edits, and committed trees. It cannot record rejected hypotheses, transient test assertions, or the operational rationale behind a deferred refactor. Furthermore, modern software engineering relies heavily on non-committable, read-only exploratory actions—such as inspecting running service logs, profiling memory usage, or checking system metrics. In a strict process-reset harness, killing the CLI process after every step makes exploratory work prohibitively expensive; the runtime must either force intermediate diagnostic output onto disk or batch exploratory reads with mutations, inadvertently inviting context bloat back into the loop.

To test whether a git tree alone can sustain an amnesic loop, you can run an outside verification check on a controlled repository.

The Outside Check: Dependency Incompatibility Stress Test

Set up a reproducible benchmark in a controlled test repository:

1. Introduce a dependency incompatibility where the primary API entry point for a package has changed between minor versions (for instance, an authentication library that deprecated verifyToken in favor of an asynchronous authenticateSession).
2. Task an amnesic agent with resolving a failing test suite across five micro-steps, terminating the CLI process after every file write.
3. Configure the supervisor to gate commits strictly on unit test execution, resetting the working tree via git reset --hard HEAD on failure.
4. Run the experiment in two configurations: first, using a pure git working tree with zero auxiliary state; second, using a supervisor that appends failure reasons to an on-disk .harness/rejected_hypotheses.md file injected into the boot prompt.

In the pure git configuration, you will observe the agent thrashing: the model repeatedly rediscovers the legacy method name in old documentation or comments, tries it, fails the supervisor test, resets, and tries it again. By contrast, an agent equipped with an on-disk negative ledger reads the previous rejection, bypasses the dead end, and tests alternative interfaces.

Treating the repository as a structured environment rather than an in-memory buffer—a paradigm explored further in Code Mode vs Function Calling for Multi-Step Agents—is fundamentally sound. However, relying exclusively on git diffs without an explicit mechanism for negative knowledge is an operational trap. Deterministic execution requires preserving rejected intent outside dialogue memory.

The Architectural Decision Matrix for Unattended Harnesses

Selecting an operational harness requires moving past the illusion that prompt tuning alone can tame context decay. The structural tradeoffs between stateful continuity and amnesic isolation come down to where authority lives, how verification executes, and what penalties you tolerate at execution boundaries.

Mechanical Dimension	Stateful Monolithic Sessions	Compaction & Scratchpad Agents	Amnesic Process-Reset Harnesses
State Authority	In-memory dialogue buffer; raw conversation transcript is primary.	Compressed conversational memory, dynamic AST/repo maps, and auxiliary scratchpad files.	Strict disk reality and git working tree; conversational memory is completely disposable.
Process Lifecycle	Continuous, long-lived containerized process across all steps.	Long-lived interactive thread maintained with rolling checkpoint boundaries.	Ephemeral, single-shot CLI invocations aggressively killed after each discrete micro-step.
Verification Mechanism	Conversational self-reporting; model checks its own terminal output inside the thread.	In-session tool and test feedback loops evaluated within active dialogue context.	Out-of-band external supervisor executing deterministic linters, unit tests, and tiered diff audits.
Rollback Strategy	Context backtracking or conversational apologies; unwinding polluted memory is fragile.	Checkpoint restoring to prior conversational state or rolling back tracked file snapshots.	Deterministic git reset --hard HEAD discarding dirty workspace states immediately on verification failure.
Context Decay Risk	Critical; unbounded accumulation of diagnostic spew, compiler traces, and invalidated assumptions.	Moderate; semantic compression drops critical constraints while stale logs continue to poison turns.	Near zero; every micro-step begins with an unpolluted attention window anchored strictly to current code.
Cold-Start Latency	Minimal; workspace layout and navigational paths remain warm throughout execution.	Low; structural topology is preserved across turns via cached summaries and scratchpads.	High; every micro-step incurs an environmental re-discovery tax unless primed by the supervisor.

The fundamental tension is clear: monolithic sessions trade long-term stability for zero cold-start latency, running at maximum speed until context poisoning triggers a fatal hallucination loop. Compaction loops attempt a middle path, but rolling summaries inevitably discard the exact subtle constraint required to prevent a regression while preserving stale diagnostic cruft. Amnesic loops eliminate context corruption entirely by treating execution as a series of stateless transactions against disk. The price is paid in cold-start rediscovery tokens and a hard dependence on external orchestration. If you do not engineer that external harness properly, the purity of an amnesic attention window will be squandered on environmental re-indexing and negative-knowledge thrashing.

Workload Boundaries: Choosing Between Process Resets and Compaction

Architectural choice should follow the autonomy boundary and the temporal duration of your task. When a human developer sits in the loop, low latency and conversational continuity dominate. When an agent runs unattended across dozens of micro-steps, context degradation becomes the primary failure mode, demanding structural isolation over conversational warmth.

Adopting an amnesic architecture in production requires recognizing that wiping dialogue memory shifts the engineering burden out of the prompt and directly into your runtime infrastructure. To survive unattended operation, you must engineer two mandatory pieces of scaffolding around the reset boundary:

First, enforce ruthless container recycling and workspace isolation. Merely issuing a termination command to a primary agent CLI process leaves detached background daemons, dangling test runners, and unclosed port bindings intact. Every micro-step must run in an isolated namespace, disposable container, or sandbox where the entire process tree is aggressively reaped upon exit. Furthermore, the supervisor must enforce transactional atomicity: if an agent process exits leaving syntactically broken files or linter errors, the supervisor must immediately issue git reset --hard HEAD to prevent passing a fragmented, corrupt repository state to the incoming clean-slate agent.

Second, solve negative knowledge amnesia through a structured supervisor blackboard. Because the git working tree only records accepted positive mutations, it cannot capture what failed. The external supervisor must maintain an append-only on-disk ledger (such as .harness/rejected_hypotheses.md) recording the attempted patch, the diff summary, and the supervisor failure response. Injecting this compact record directly into the boot prompt alongside a pre-computed workspace manifest eliminates both cyclical diff oscillation and the cold-start rediscovery penalty.

Resources

• Autonomous Coding Scales Through Process Resets Rather Than Context Retention