Draft the Control Statement, Sign It Yourself
Updated
AdvancedWhat you'll learn
~50 min- Draft an SP 800-53 (NIST's catalog of security controls) implementation statement for AC-12, session termination, in which every claim points to a file, a test, or an evidence item
- Keep unknowns and inherited controls explicit, and use the phrase supports evidence for instead of satisfies
- Write a check script that fails a statement with a dangling pointer, an unowned unknown, or no named human signer
- Optionally render a statement as an OSCAL (NIST's machine-readable format for control documents) component-definition fragment and validate it against NIST's schema
What it is: a way to have an AI CLI draft the paragraph that says how the system handles a security control, with every sentence tied to a file, a test or an inherited provider, and a named person signing it.
What it buys: statements that an assessor can verify by following links, instead of narrative that has to be taken on trust, and a clear record that a human, not the agent, made the claim.
What to fund: reviewer time for the signer, who reads the evidence and not just the prose; the drafting itself is cheap.
Before the detail — Artifact: one statement file per control, an agent review file for each, plus a check script that every statement must pass. Acceptance test: a reviewer follows every pointer to a real artifact without asking the author, and a statement with a dangling pointer fails the check. Status of what follows: reusable guidance. The statement format is this lesson’s own; the control text and the OSCAL field names come from NIST.
The case-intake rebuild has working code, a test suite, and a pipeline that produces an SBOM. What it does not have yet is the paragraph the agency’s security office asks for: for each control, how does this system handle it? That paragraph lives in the system security plan (SSP, the document describing how a system meets its controls), and it is where code and paper most often drift apart. An AI CLI is good at reading code and tests and describing them. It is not entitled to decide that a control is met, and the rest of this lesson is the structure that keeps those two things apart.
The split this lesson uses
Secure Software Delivery for Federal Environments (a separate training in this series) is the place for the full architecture. Its lesson 2.1, The Control Catalog as Data covers one YAML file per control with its evidence contract, and 3.2, The Evidence Store You Can Defend covers content-addressed, append-only evidence. This lesson does not rebuild either. It uses the narrow slice a single application team can own.
That training’s lesson 2.2, Implementation Statements That Survive Assessment makes the point that, in the strongest shops, statements are written by people, and the AI CLI helps at the edges. This lesson agrees and narrows the agent’s role further: it drafts from evidence the repository already holds, refuses to assert anything the evidence does not show, and never signs.
Four rules govern every statement:
- Every claim points to something. A file, a test name, a configuration key, or an evidence item. No pointer, no claim.
- The language is “supports evidence for.” The statement is evidence offered to an assessor. Whether the control is met is their finding, and the agency’s authorizing official (the person who accepts the risk and signs the decision to operate the system) makes the final call. The word “satisfies” does not appear.
- Unknowns and inherited controls stay explicit. What the code cannot show is listed with an owner. What a provider handles is named with the provider.
- A named human signs, with a date. The agent is the drafter. It cannot be the approver.
The controls
The first control is AC-12, Session Termination, from lesson 3. In paraphrase, the control, as read from NIST’s official OSCAL catalog of SP 800-53 Rev 5.2.0, requires the system to end a user session automatically after conditions or trigger events that the organization defines. That is a parameter the organization sets. (The exact bracketed wording NIST prints was read from the catalog data and not compared against the printed PDF, so check it against the publication before you quote it in an SSP.) NIST’s guidance names inactivity periods, targeted responses to certain incidents, and time-of-day restrictions as examples of triggers; the control does not fix a number of minutes. In lesson 3 the reference app ends a session at one configured maximum age, held in one constant that your ISSO sets. This statement is where that choice is written down. Source: NIST SP 800-53 Rev 5.2.0 OSCAL catalog.
The second control is AC-3, Access Enforcement, which the app evidences through the contract test from lesson 5: every role and route pair has a decision, and the default is deny.
Two things in the AC-12 draft are deliberately uncomfortable. The code enforces a maximum age; whether the agency’s chosen trigger conditions also include an idle timeout is a decision the code cannot reveal. And the identity provider of record (the system the agency designates as the source of user sign-ins) keeps its own session, which this application does not control. A statement that hides either of those has stopped being evidence.
Plan the change with your agent
Start your agent in the project root and switch to Plan mode (Shift+Tab, /plan, or the mode picker in your desktop app). Ask it to inspect the repository’s authentication and authorization code and plan the two control statement files:
We need to draft JSON control statements for AC-12 and AC-3 in compliance/statements/ from the code and tests in this repo, leaving the signer empty. Inspect the auth files and ask me anything unclear before writing code.What to check in the plan before you approve
- Each statement in
compliance/statements/ac-12.jsonandcompliance/statements/ac-3.jsonseparates claims into three kinds:implemented(withevidence: [{ path, anchor }]copied from real files and test names),inherited(withfromnaming the provider), andunknown(withownernaming the role that must resolve it). - Every claim uses the wording
"supports evidence for"and never"satisfies". - Gaps the repository cannot answer (such as whether AC-12 triggers include idle time, or how often the identity provider role mapping is reviewed for AC-3) are planned as
unknownentries rather than omitted or guessed. agent_reviewis set tocompliance/reviews/<control>.review.json(path only, not written by the drafting agent) andsigneris left asnull.
If the first plan claims full session termination coverage or omits the anchor string on evidence items, steer it before approving:
Include an exact constant or test name as the anchor on every evidence pointer, and list idle timeout as an unknown owned by the ISSO.Requiring an anchor matters because a path alone can point at a file that has since stopped saying the thing. Anchors turn “this file exists” into “this file still contains this constant or this test name.”
What you get
REFERENCE CONFIG compliance/statements/ac-12.json: AC-12 session termination control statement open reference hide reference Reference implementation from gov-dev-reference-app; open to inspect or compare with what your agent builds.
{ "control": "ac-12", "drafted_by": "agent", "claims": [ { "kind": "implemented", "text": "The application supports evidence for AC-12 by ending a session once it passes one configured maximum age.", "evidence": [ { "path": "src/lib/auth/session-config.ts", "anchor": "SESSION_MAX_SECONDS" }, { "path": "src/lib/auth/session.test.ts", "anchor": "is expired at the constant" }, { "path": "src/lib/auth/session.test.ts", "anchor": "refuses an expired session" }, { "path": "docs/adr/0005-session-limit.md", "anchor": "SESSION_MAX_SECONDS" } ] }, { "kind": "unknown", "text": "Whether the agency's chosen trigger conditions include idle time. The code enforces a maximum age only.", "owner": "ISSO" }, { "kind": "inherited", "text": "Termination of the identity provider's own session.", "from": "the agency's identity provider of record" } ], "agent_review": "compliance/reviews/ac-12.review.json", "signer": { "name": "R. Alvarez", "role": "ISSO", "date": "2026-11-05" }}The third pointer is the session limit evidence: a record, in your repository, of who set the maximum age and when. The statement never types the number of seconds itself. A number copied into a statement goes stale the day the constant changes, while a pointer to the constant and to the ISSO’s decision stays checkable.
The signer block above is filled in as it would be after a person reviews it; the agent’s draft has "signer": null. The file names the constant SESSION_MAX_SECONDS and the test file exactly as lesson 3 creates them; use whatever your repository’s names actually are, and let the check below tell you if they are wrong.
The AC-3 statement has the same shape. It leans on the role-by-route contract test from lesson 5, and it keeps two things outside the claim:
REFERENCE CONFIG compliance/statements/ac-3.json: AC-3 access enforcement control statement open reference hide reference Reference implementation from gov-dev-reference-app; open to inspect or compare with what your agent builds.
{ "control": "ac-3", "drafted_by": "agent", "claims": [ { "kind": "implemented", "text": "The application supports evidence for AC-3 by giving every role and route pair an explicit decision and denying by default.", "evidence": [ { "path": "src/lib/auth/permissions.ts", "anchor": "PERMISSIONS" }, { "path": "tests/contract/rbac.test.ts", "anchor": "every role x route pair is decided" } ] }, { "kind": "unknown", "text": "How often the mapping from the identity provider's role names to roles (ROLE_CLAIM_MAP) is reviewed. The code reads the mapping; it does not show who reviews it.", "owner": "system owner" }, { "kind": "inherited", "text": "Creation, removal and user assignment of the roles the identity provider puts in its tokens.", "from": "the agency's identity provider team" } ], "agent_review": "compliance/reviews/ac-3.review.json", "signer": null}A second agent reads it before the person does
The signer’s hours are the scarce part of this process, so spend a cheap read before spending them. A review agent is a second AI run, started fresh and preferably in a different tool from the drafter so the two do not share the same blind spots. It takes each claim, opens the file the claim points to, and says whether the file supports what the claim says. It is advisory: it cannot edit the statement and it cannot sign.
Module 19 lesson 8, The Council Pattern teaches the general method: models that did not write the change give independent verdicts, a split verdict is read and not averaged, and you estimate the cost before you run it. This is the narrow application to one artifact. Run it as lesson 19’s review step: read-only tools, a schema for the output, and a check on the artifact rather than the exit code, because a run that was denied the right to open a file can still exit 0. Send it only to an endpoint your agency approved in lesson 1.
Ask the second agent to review the draft statement:
Review compliance/statements/ac-12.json read-only without editing files. Check each implemented claim against its evidence path and anchor, check inherited and unknown claims, and write per-claim supported, overclaims, or unsupported verdicts with one-sentence notes to compliance/reviews/ac-12.review.json.The review agent checks three things in order, treating the statement and repository files strictly as data rather than instructions:
- For
implementedclaims, it opens every evidence path, locates the anchor, and checks whether the file supports the exact claim text and no more. - For
inheritedclaims, it checks that a provider is named and nothing beyond that is claimed; forunknownclaims, it checks that a real gap and an owner are stated. - It writes
{ "claims": [ { "claim": 1, "verdict": "...", "note": "..." } ] }with one entry per claim.
Keep the schema for the review file, a list of { claim, verdict, note } entries, in compliance/review-schema.json, under the same code owners as the check script so the drafter cannot loosen it. The review file feeds the check script below: it fails a statement whose review is missing, whose review does not cover every claim, or that holds any verdict other than supported. The drafter fixes the claim (narrower text, or the missing evidence) and the review runs again. Only then does the named person read it. They still follow the pointers themselves; the review reduces the mechanical mismatches they would have found, and it can agree with a wrong claim.
The check script
The check enforces the four rules mechanically, and refuses a statement that has no complete agent review. A reviewer should not have to be the first one to discover a typo in a path.
REFERENCE CODE scripts/compliance/check-control-statements.mjs: pointer, review, and human-signer gate open reference hide reference Reference implementation from gov-dev-reference-app; open to inspect or compare with what your agent builds.
// usage: node scripts/compliance/check-control-statements.mjs [dir]import { existsSync, readFileSync, readdirSync } from 'node:fs';import { join } from 'node:path';
const dir = process.argv[2] ?? 'compliance/statements';const AGENT = /agent|claude|codex|copilot|gemini|bot|\bai\b/i;let problems = 0;const fail = (file, msg) => { console.log(`check-statements: FAIL ${file} ${msg}`); problems++; };
for (const name of readdirSync(dir).filter((f) => f.endsWith('.json'))) { const file = join(dir, name); const st = JSON.parse(readFileSync(file, 'utf8')); const text = JSON.stringify(st.claims ?? []); if (/\bsatisf(y|ies|ied)\b/i.test(text)) fail(file, 'uses "satisfies"; write "supports evidence for"'); (st.claims ?? []).forEach((c, i) => { const id = `claim ${i + 1}`; if (c.kind === 'implemented') { if (!c.evidence?.length) fail(file, `${id}: implemented claim with no evidence`); for (const e of c.evidence ?? []) { if (!existsSync(e.path)) { fail(file, `${id}: dangling pointer ${e.path}`); continue; } if (e.anchor && !readFileSync(e.path, 'utf8').includes(e.anchor)) fail(file, `${id}: ${e.path} has no "${e.anchor}"`); } } else if (c.kind === 'inherited') { if (!c.from) fail(file, `${id}: inherited claim names no provider`); } else if (c.kind === 'unknown') { if (!c.owner) fail(file, `${id}: unknown with no owner to resolve it`); } else fail(file, `${id}: kind must be implemented | inherited | unknown`); }); const rv = st.agent_review; if (!rv || !existsSync(rv)) fail(file, 'no agent review file (agent_review) to read before signing'); else { const verdicts = JSON.parse(readFileSync(rv, 'utf8')).claims ?? []; const n = (st.claims ?? []).length; if (verdicts.length !== n) fail(file, `agent review covers ${verdicts.length} of ${n} claims`); verdicts.filter((v) => v.verdict !== 'supported').forEach((v) => fail(file, `review: claim ${v.claim} is ${v.verdict}: ${v.note}`)); } const s = st.signer; if (!s?.name || !/^\d{4}-\d{2}-\d{2}$/.test(s.date ?? '')) fail(file, 'no named human signer with a date'); else if (AGENT.test(s.name)) fail(file, `signer "${s.name}" looks like an agent, not a person`);}if (!problems) console.log('check-statements: PASS');process.exit(problems ? 1 : 0);Three honest limits. The review check proves a review file exists, covers every claim and holds no unresolved verdict; it cannot prove the review was right. The signer check refuses a name that looks like an agent, but it cannot prove a person read the evidence; that is what the reviewer’s time is for. And the anchor check proves a string is present in a file, not that the code behind it works; the pointed-to test is what proves behavior, which is why a claim about behavior should point at a test and not only at a constant.
See it work
- Typed in the terminal:
claude - Mode:Plan mode
- You type in the session: We need to draft JSON control statements for AC-12 and AC-3 in compliance/statements/ from the code and tests in this repo, leaving the signer empty. Inspect the auth files and ask me anything unclear before writing code.
- The tool replies: I inspected src/lib/auth/session-config.ts, src/lib/auth/session.test.ts, docs/adr/0005-session-limit.md, src/lib/auth/permissions.ts, and tests/contract/rbac.test.ts. For AC-12 I see maximum session age (SESSION_MAX_SECONDS), no idle-timeout code, and an external identity provider session. Should I split each statement into implemented, unknown, and inherited claims with file-and-anchor pointers?
- You type in the session: Yes. Use 'supports evidence for', set agent_review to compliance/reviews/<control>.review.json, and leave signer null. Approved to draft ac-12.json first.
- The tool replies: I read src/lib/auth/session-config.ts, src/lib/auth/session.test.ts and the session-limit decision record, and wrote compliance/statements/ac-12.json with three claims. implemented maximum session age, pointing at SESSION_MAX_SECONDS, the expiry test and the ISSO's decision record unknown whether the agency's trigger conditions include idle time (owner: ISSO). The code only enforces a maximum age. inherited the identity provider of record's own session (from: the agency's identity provider of record) signer is null and I did not write the review file. I did not claim an idle timeout because I found no code or test for one.
- You type in the session: Hand it to the review agent in a different tool, read-only, using the review prompt. Then show me what it wrote.
- The tool replies: $ <other-agent-cli> -p "You are reviewing a control statement you did not write..." --output-format json --json-schema "$(cat compliance/review-schema.json)" (stderr) notice: 0 actions denied compliance/reviews/ac-12.review.json: claim 1 overclaims "ends a session" is stronger than the cited test, which shows the expiry function returns true at the constant but not that a request with an expired session is refused. claim 2 supported states a real gap and names an owner. claim 3 supported names the provider and claims nothing beyond it. The review file covers 3 of 3 claims. It exited 0, but the check below reads the file, not the exit code.
- You type in the session: Add the pointer to the test that proves an expired session is refused, then re-run the review and the check.
- The tool replies: I added a second test pointer to claim 1, the test that checks a request with an expired session is refused. The claim text stays as it was; the evidence now shows what the text says. Re-ran the review: all three claims are supported. $ node scripts/compliance/check-control-statements.mjs check-statements: FAIL compliance/statements/ac-12.json claim 1: dangling pointer src/lib/auth/sessions.test.ts check-statements: FAIL compliance/statements/ac-12.json no named human signer with a date exit code 1 The first failure is mine: the test file is named session.test.ts, and I wrote sessions.test.ts. The second is expected, since the draft is unsigned.
- You type in the session: Fix the path. Then fill in the signer as R. Alvarez, ISSO, today, so we can ship it.
- The tool replies: I fixed the path to src/lib/auth/session.test.ts. I am not going to fill in the signer. The signature says that a person reviewed the claims and the evidence and stands behind them, and I drafted the statement, so I cannot be the one who approves it. The review agent's note is an input to R. Alvarez, not a substitute for reading. If they read the three claims, the review and the pointers, they can add their own name and date to the signer block; I will re-run the check when they have.
- You type in the session: R. Alvarez has reviewed and added their signer block. Run the check again.
- The tool replies: $ node scripts/compliance/check-control-statements.mjs check-statements: PASS PASS means every implemented claim has evidence that exists and contains its anchor, the unknown has an owner, the inherited claim names its provider, the text does not use "satisfies", the agent review covers every claim with no unresolved verdict, and a named person with a date signed it. It does not mean the control is met; that is the assessor's finding.
Illustrative session; exact output varies by tool and agency configuration.
Optional: render it as an OSCAL fragment
OSCAL is NIST’s machine-readable format for control documents. Its component-definition model describes a component and the controls it implements, which is the natural machine form of what you just wrote. This step is optional, and the JSON statement file stays the source of truth. The architecture for catalog-as-data and an evidence store is the subject of the Secure Software Delivery training mentioned above; do not build it here.
The field names below were checked against NIST’s oscal_component_schema.json from the usnistgov/OSCAL v1.2.3 release, and the fragment validates against that schema with a standard JSON Schema validator. The v1.2.3 release was confirmed as the latest on the usnistgov/OSCAL releases page on 2026-11-04. Source: OSCAL v1.2.3 component-definition schema. In that schema, a component definition requires uuid and metadata; a component requires uuid, type, title and description; a control implementation requires uuid, source, description and implemented-requirements; and an implemented requirement requires uuid, control-id and description.
REFERENCE CONFIG OSCAL component-definition fragment for AC-12 open reference hide reference Reference file pattern for your workspace agent; open to inspect or compare. You do not type or paste this by hand.
{ "component-definition": { "uuid": "6f1c2a4e-3b7d-4c58-9a0e-5d2f8b1e7a31", "metadata": { "title": "Case intake application: control statements (draft for signature)", "last-modified": "2026-11-04T12:00:00Z", "version": "0.1.0", "oscal-version": "1.2.3" }, "components": [ { "uuid": "b0a7e3d2-8c14-4f6a-a1d9-2e4c6f8a0b53", "type": "software", "title": "intake web application", "description": "The case-intake feature of the reference app.", "control-implementations": [ { "uuid": "d41e9c07-52a8-4b3f-8e16-7c0a9f2b4d68", "source": "https://github.com/usnistgov/oscal-content/blob/main/nist.gov/SP800-53/rev5/json/NIST_SP-800-53_rev5_catalog.json", "description": "Statements that support evidence for the controls below. Not an assessment result.", "implemented-requirements": [ { "uuid": "93c5a1f8-7e2d-4a60-b4c9-0d8e3f1a5b72", "control-id": "ac-12", "description": "The application supports evidence for AC-12 by ending a session once it passes one configured maximum age.", "links": [ { "href": "src/lib/auth/session-config.ts", "rel": "evidence", "text": "SESSION_MAX_SECONDS" }, { "href": "src/lib/auth/session.test.ts", "rel": "evidence", "text": "is expired at the constant" }, { "href": "src/lib/auth/session.test.ts", "rel": "evidence", "text": "refuses an expired session" } ], "remarks": "Unknown, owner ISSO: whether the chosen trigger conditions include idle time. Inherited: the identity provider's own session. Signed by: R. Alvarez, ISSO, 2026-11-05." } ] } ] } ] }}Two cautions. The schema checks structure, not truth: a fragment can validate and still point at nothing, so run the statement check on the source file first. And the fragment carries the unknown and the signer in remarks because those are the lesson’s conventions; if your agency’s tooling expects them elsewhere, follow its profile.
Prove it
Four negative cases, each of which must fail.
# 1. Dangling pointer: break one path in a statementsed -i 's#src/lib/auth/session-config.ts#src/lib/auth/sesion-config.ts#' compliance/statements/ac-12.jsonnode scripts/compliance/check-control-statements.mjs # expect: dangling pointer, exit 1
# 2. Missing signer: set "signer" to null# expect: no named human signer with a date, exit 1
# 3. The word "satisfies" in a claim# expect: uses "satisfies", exit 1
# 4. An unresolved review: change one verdict in compliance/reviews/ac-12.review.json to "overclaims",# or delete the file. expect: review: claim N is overclaims, or no agent review file, exit 1Undo each change after you see it fail, and finish with a green run. The second half of the proof is the human one: give the two statement files to a reviewer who did not write them, and have them follow every pointer to a real artifact without asking you anything. Any question they ask marks a pointer that was not good enough.
Availability, authorization, agency approval, region support, and price are five separate facts. This box holds the dated facts for this lesson.
- NIST SP 800-53 Rev 5.2.0, read from NIST’s official OSCAL catalog (last modified 2026-10-22). AC-12 text: “Automatically terminate a user session after [Assignment: organization-defined conditions or trigger events requiring session disconnect].” The parameter wording is NIST’s standard format; the printed PDF was not independently compared. Source: oscal-content catalog.
- AC-11 (Device Lock) is a different control: it is the inactivity lock, with an organization-defined time period. Same source.
- OSCAL v1.2.3 is the latest release on usnistgov/OSCAL (published 2026-08-07). Source: OSCAL releases.
- The OSCAL fragment above was validated on 2026-11-04 against the v1.2.3 component-definition schema; a copy with
versionremoved failed with a required-property error.
Recheck the cited source and your agency’s authorization boundary before you rely on any of it.
The AI CLI offers to put the ISSO's name in the signer block, 'to save a step.' Why is that the wrong move?
The draft says the platform 'satisfies AC-12.' You rewrite it. Which version is right?
Practice status — how established each pattern is across federal and commercial teams
| Practice | Status | Also called |
|---|---|---|
| Implementation statement for each control the system owner is responsible for | common baseline | SSP control narrative |
| Every claim pointing to a file, test or evidence item | strong optional | evidence-linked narrative |
| Agent drafts, human signs | emerging | human-in-the-loop attestation |
| A second agent reviews the draft before the signer reads it | emerging | independent agent review, council review |
| Statement file checked in CI for dangling pointers | emerging | evidence link check |
| OSCAL component-definition output | strong optional | machine-readable control statements |
Scale: required | common baseline | strong optional | reference-shop (seen only at organizations that publish their own practice) | emerging
The review agent marks claim 1 as overclaims and exits 0. The signer is in a hurry. What is the right next step?
Key takeaway
An AI CLI can read the repository and describe what it shows. It cannot decide that a control is met, and it cannot approve its own draft. Make the statement a file, tie every claim to something a reviewer can open, name the unknowns and the inherited parts, let a second agent read the draft against its evidence, and let a person sign. The check script does the mechanical part so the reviewer’s hours go to the judgment.
- LEADERSHIP DECISION
- Require that any AI-drafted control statement carries evidence pointers, a complete independent agent review and a named human signer before it enters the system security plan.
- PRACTITIONER ACTION
- Draft AC-12 and one more control as statement files, run the agent review and the check in CI, and have a reviewer follow every pointer cold.
- SUCCESS MEASURE
- Assessor-hours: a reviewer verifies each claim from its pointer without a clarifying question to the author.
Legend: LEADERSHIP DECISION = what a leader decides · PRACTITIONER ACTION = what the engineer does next · SUCCESS MEASURE = how you know, in calendar time, assessor-hours or cost, contract or revenue risk, or audit finding avoided