The AI-Agent Completion Protocol — rendered package. Rendered from ai-agent-completion-protocol.md; frozen technical content unchanged by rendering.

The AI-Agent Completion Protocol

Internal working document — published for transparency. This page is part of the tooling used to build and verify this site’s gate ledgers — it documents process, not physics. It is kept public so the build discipline itself can be inspected. The physics closure-of-record is the gate board; start at the anchors overview.

A page is not complete when text exists. A page is complete when every claim is traced, typed, tested, status-limited, and accepted by a verifier.

Why this page exists

The other /anchors/ pages state what the program claims and exactly how strong each claim is. This page is the utility layer underneath them: it tells the AI orchestrator how to break each page into atomic tasks, how to write the acceptance tests that decide whether a content agent actually finished, and how a separate verifier agent accepts or rejects each unit before it is integrated.

The motivation is a specific, well-documented failure mode of capable language models: they produce polished partial answers. Fluent prose reads as completion even when a status label was silently promoted, a derivation was smuggled in without its "given $E$" qualifier, or an open residual was quietly dropped. The protocol exists to make completion testable rather than felt — to convert "this reads well" into "this passes its declared tests."

The discipline throughout is the program's spine: selection ≠ derivation · given-E ≠ derivation-of-E · frozen / reproducible ≠ proven-unique. Every test below exists to catch a place where one of those three could be silently violated by a confident agent.

Allowed status labels (the only labels any agent may apply on any anchor page): DECLARED ROOT · GENERATED · DERIVED-GIVEN-E · MEASURED · CHARGED · AUDIT ONLY · OPEN · BLOCKED · ANTI-CLAIM.

No agent may invent a status, soften a status, or promote OPEN/DECLARED ROOT into anything stronger.

The core rule

$$ \boxed{\text{No AI agent receives a vague page task. Every agent receives an atomic deliverable plus acceptance tests.}} $$

A page task is never handed to a content agent whole. The orchestrator decomposes it into atomic deliverables, attaches acceptance tests to each, and only then assigns it. The tests are written before the task is assigned, so the agent cannot reverse-engineer "done" from its own output.

The recursive decomposition algorithm (P1)

The orchestrator turns a page goal into assignable atomic tasks by recursively splitting until each unit is small enough that its failure would be obvious to a test. The ten steps, in order:

  1. Start with the page goal.
  2. Split into major sections.
  3. Split each section into claim-blocks.
  4. Split again if the claim-block has multiple roots / gates / calculations / statuses.
  5. Stop only when the task is atomic (see the atomic-task definition below).
  6. Generate tests before assigning the task (every requirement becomes at least one test).
  7. Require a completion report from the content agent.
  8. Verify with a separate verifier agent.
  9. Integrate only passing units.
  10. Run page-level universal tests (U1–U8) on the assembled page.

The loop is genuinely recursive: step 4 may re-enter at step 3 for a sub-block, and the complexity score below decides when to stop versus split.

The atomic task definition (P2)

A task is atomic when all of the following hold:

If any clause fails, the task is not atomic and must be split again. The stop rule that governs the whole recursion:

$$ \boxed{\text{If failure would be hard to detect, the task is still too large.}} $$

Detectability — not word count alone — is the real criterion. A 300-word task that quietly bundles two statuses is still too large, because a status error in it would be hard to catch.

The complexity scoring rule (P3)

To decide whether a candidate task is atomic, assignable-with-one-split, or must be split recursively, the orchestrator scores it:

$$ C = 2N_c + 3N_e + 3N_g + 2N_s + 4N_o + 5N_u $$

where:

The weights are deliberately top-heavy on the failure-prone dimensions: open residuals ($4$) and unresolved ambiguities ($5$) cost the most because they are exactly what a confident agent tends to drop or paper over. The decision table:

Complexity score Action
$C\leq 8$ assignable atomic task
$9\leq C\leq 16$ split once
$C>16$ split recursively
any $N_u>0$ clarify or isolate specialist question

Note the last row overrides the others: any unresolved ambiguity ($N_u>0$) forces a clarification or a routed specialist question before assignment, regardless of the numeric score.

The content-agent prompt template (P4)

Every content agent receives a prompt in this fixed shape. It is copyable verbatim; the orchestrator fills each field.

You are writing one atomic section of the Anchor Hierarchy project. Do not write the whole page. Do not change status labels. Do not promote open claims into closed claims.

Task ID:
Objective:
Required inputs:
Output format:
Acceptance tests:
Forbidden overclaims:
Completion report:

The agent must return a completion report in exactly this format (P10):

Tests passed:
Tests failed:
Open items:
Assumptions made:

The three opening prohibitions — do not write the whole page · do not change status labels · do not promote open claims into closed claims — are the standing anti-overclaim guard carried in every assignment.

The verifier-agent prompt template (P5)

Acceptance is decided by a separate agent from the one that wrote the section. The verifier does not rewrite; it checks the output against the acceptance tests exactly.

You are verifying whether an AI content agent completed an atomic section. Do not rewrite the section unless asked. Check the output against the acceptance tests exactly.

Return:
1. PASS or FAIL.
2. Failed tests.
3. Missing required content.
4. Any overclaims.
5. Any unsupported derivations.
6. Any hidden open residuals.
7. Required revision instructions.

Items 4–6 are the credibility checks: overclaims, unsupported derivations (e.g. an OPEN item written as DERIVED-GIVEN-E, or a "given $E$" qualifier dropped), and hidden open residuals. A unit integrates only on PASS (step 9).

The test-generation method (P6)

The orchestrator does not write tests by intuition. It applies one mechanical rule:

$$ \boxed{\text{Every requirement becomes at least one test.}} $$

Each requirement of the atomic task is mapped to one or more tests drawn from a fixed type list, so that no requirement is left unchecked:

These seven types are sufficient to cover the universal tests U1–U8 below; the orchestrator selects whichever apply to the atomic task at hand.

Page-level universal tests (P7)

After a content unit passes verification and before it is integrated, and again on the assembled page (step 10), the orchestrator runs the universal completion tests. These are the same eight every anchor page must pass:

Each universal test maps directly onto one of the test types in P6 (status, traceability, anti-overclaim, open-residual, completion-report), so U1–U8 are mechanically checkable, not editorial.

Final-site integration tests (P8)

The universal tests above run per page. The following six run across the whole site, after the individual pages pass, to guarantee that the pages agree with one another:

  1. Root consistency — the same seven-root hierarchy appears everywhere (Invariance, Record Interface, Causal Order, Granularity, Scale, Shape, Nonseparability).
  2. Status consistency — the same status labels are used everywhere; no page introduces a new or softened label.
  3. No contradiction between pages — no page asserts what another denies (e.g. one page calling a gate closed that another lists OPEN).
  4. Gate tables complete where gate pages exist — every gate page carries its required gate-traceability row family.
  5. Forbidden claims absent by search — a literal text search for the forbidden overclaims returns nothing.
  6. Nothing floats — every named anchor, on every page, answers type / root / master / status / claim / anti-claim.

Test 5 is run as an actual string search (the QA grep), not a reading pass, so it cannot be defeated by a confident summary.

The orchestrator invariant (P9)

Two boxed invariants govern the whole protocol. The first is per-task; the second is per-page.

$$ \boxed{\text{A task is not complete when text exists. A task is complete when tests pass.}} $$

$$ \boxed{\text{A page is not complete when it reads well. A page is complete when every claim is traced, typed, tested, and status-limited.}} $$

Both restate the page thesis at the two scales the orchestrator actually operates on, and both deliberately reject fluency as evidence of completion.

Allowed status labels (the only labels any agent may use)

DECLARED ROOT · GENERATED · DERIVED-GIVEN-E · MEASURED · CHARGED · AUDIT ONLY · OPEN · BLOCKED · ANTI-CLAIM.

Global forbidden overclaims (the anti-overclaim test set)

Every content-agent prompt carries these, and the anti-overclaim test (P6) and final-site search (P8 test 5) hunt for them:

These eight are the exact mirror of the program's honest spine: each one is a place where a polished partial answer would over-promote a selected / given-E / OPEN / AUDIT ONLY result into a derivation or a uniqueness theorem.

How the pieces fit (worked summary)

Putting the protocol in one pass, for a single page:

  1. The orchestrator scores the page goal with $C=2N_c+3N_e+3N_g+2N_s+4N_o+5N_u$ and splits (decomposition steps 1–5) until every unit satisfies the atomic-task definition and the stop rule.
  2. For each atomic unit it generates tests (every requirement $\to$ at least one test; types from P6), then fills the content-agent template (P4) and assigns it.
  3. The content agent returns its section plus the four-line completion report.
  4. A separate verifier agent (P5) returns PASS/FAIL with failed tests, missing content, overclaims, unsupported derivations, hidden open residuals, and revision instructions.
  5. Only PASS units are integrated (step 9); the assembled page is run through the universal tests U1–U8 (P7).
  6. Across all pages, the six final-site integration tests (P8) confirm consistency, no contradiction, and — by literal search — the absence of every forbidden overclaim.

At no step is "reads well" accepted as "done"; the two boxed invariants (P9) are the contract.

Global discipline — forbidden overclaims this page obeys

This page is a process-control utility; it asserts no physics anchor of its own, so it has no DECLARED ROOT / DERIVED-GIVEN-E content to over-promote. Its only typed object is the protocol itself, which is CHARGED (a declared process control), and the forbidden-overclaim set, each item of which is an ANTI-CLAIM.

Completion report

Tests passed. - P1 — Recursive decomposition algorithm: all ten steps present, in order. - P2 — Atomic task definition: all seven clauses plus the boxed stop rule present. - P3 — Complexity scoring formula $C=2N_c+3N_e+3N_g+2N_s+4N_o+5N_u$ and the four-row decision table present. - P4 — Content-agent prompt template present, copyable, with the four-line completion-report format. - P5 — Verifier-agent prompt template present (seven-item return). - P6 — Test-generation method present: boxed "every requirement becomes at least one test" plus the seven test types. - P7 — Page-level universal tests U1–U8 present. - P8 — Final-site integration tests: all six present, including search-based forbidden-claim check. - P9 — Orchestrator invariant: both boxed invariants present, plus allowed labels and forbidden overclaims. - P10 — Completion report present (this block), in the required four-field format. - U1 — Status honesty: every typed claim uses an allowed status label; none promoted. - U2 — No floating anchors: the only typed objects (the protocol = CHARGED; each forbidden overclaim = ANTI-CLAIM) are typed. - U3 — No root inflation: the page states the deep roots are not all theorem-grade. - U4 — No E-smuggling: $E$ is kept given / charged / bundled into Shape; "given $E$" preserved in U4 and the discipline block. - U5 — No hash-overclaim: hashes stated as audit integrity / frozen-object identity only. - U6 — Local / global distinction: local closure explicitly not whole-gate closure. - U7 — Forbidden claims absent: no absolute uniqueness, no anomaly-selector, no $\rho$ / hierarchy overclaim, no FTL nonseparability claim. - U8 — Completion report present (this block).

Tests failed. None.

Open items. - This page is a methodology / process-control utility; it carries no open physics residual of its own. The open residuals it helps protect (Granularity $\Rightarrow$ MDL bridge, bundle-uniqueness / given-$E$, whole-gate / cross-grammar closure) live on the deep-roots, blind-spots, and gate pages and remain OPEN there.

Assumptions made. - Adopted the handoff's required blocks verbatim in substance: core rule, recursive decomposition algorithm, atomic-task definition, complexity scoring rule, content- and verifier-agent prompt templates, test-generation method, final-site integration tests, and the orchestrator invariant. - Typed the protocol itself as CHARGED and each forbidden overclaim as ANTI-CLAIM, since this utility page asserts no physics anchor (no floating anchors result, U2). - Used $...$ / $$...$$ LaTeX for all math (including the boxed invariants and the complexity formula) so it typesets, and used only the handoff's allowed status labels.

Cross-links