Comparison

IMPLEMENTAUDIT is not trying to make an agent magical. It makes the run inspectable.

For a first run, skim the contrast this way: a normal run is mostly chat; an IMPLEMENTAUDIT run gives you a bound work record, before/after evidence, and an explicit ending. The maintainer-level comparison stays below for deeper review.

Normal agent run

A normal agent run can blur planning, editing, retrying, and completion into one chat transcript.
That can be fine for tiny work, but it is hard to audit when a repo change needs evidence.

IMPLEMENTAUDIT run

IMPLEMENTAUDIT separates those states into files and markers:

the request
work record, with a run folder when phased
state file
phase checklists
before/after checks
failure log
final audit

The key difference is not more jargon; it is a reviewable trail.

Comparison table

Question	Normal run risk	IMPLEMENTAUDIT answer
What was requested?	Buried in chat.	Bound to a work record and roadmap.
What changed?	Final answer may summarize loosely.	Repo-state comparison separates deliverables from run evidence.
What failed?	Retry history can disappear.	Failure handling records class, cause, countermeasure, rerun evidence, escalation, or handoff.
What counts as done?	The chat stops.	`AUDIT_COMPLETE` must precede `IMPLEMENTAUDIT_RUN_COMPLETE`.

Category comparison

Normal prompt

Audit object: none.
Gates: none.
Mutation: agent discretion.
Continuity: chat memory only.
Polish/harden: none by default.

Normal goal runner

Audit object: implicit goal state.
Gates: host-dependent.
Mutation: phase or agent discretion.
Continuity: host-managed when present.
Polish/harden: host-dependent.

Plain phased runner

Audit object: implicit staged goal state.
Gates: runner-managed phase gates.
Mutation: gated per phase.
Continuity: per-phase writeback when supported.
Polish/harden: usually outside the core loop.

IMPLEMENTAUDIT

Work record: explicit evidence-bearing record, with maintainer term tdqyq-audit-object, constructed or bound before mutation.
Gates: non-skippable audit gates with halt conditions.
Mutation: real-file inspection, owner/source, before/after checks, and bounded evidence.
Continuity: five-source priority preload plus explicit CONTINUITY_DECISION.
Polish/harden: optional final Polish and Harden phase.

Behavior IMPLEMENTAUDIT keeps

IMPLEMENTAUDIT keeps useful staged-runner behaviors but binds them to audit closure:

casual invocation becomes governed casual-build intake
continuity preload happens before mutation
per-phase writeback is recorded as CONTINUITY_DECISION
optional Polish and Harden is a terminal phase shape rather than a license for scope creep

What IMPLEMENTAUDIT refuses

Ungated mutation outside a live work record.
Unbounded autonomy or scope expansion without owner decision or re-authorization.
Proof without evidence type, boundary, and remaining risk.
Hidden commit, push, tag, release, publication, provenance, host install, or sidecar setup.

Boundary

This comparison is scoped to repo-changing agent work and auditability.
It is not a claim that every task needs this much structure.