# Atlas Verify

> Has a separate, independent agent check every statement and every diagram box and arrow of a knowledge-base page or work artifact against the exact source text it cites, removes or turns into questions whatever is not supported, and records the pass; for a slimmed work artifact it also has a second agent check that nothing material was dropped from the original. Use when a page or artifact is about to be proposed for commit (atlas-onboard, atlas-ask, atlas-refresh, atlas-shape, atlas-brief and atlas-check run it), when someone asks to verify or fact-check a page or artifact, or when a review banner says the second-agent check is missing or out of date.

- Skill: `chauthehienp3c1/atlas-verify` (Agent Skill, multi-file: 3 files)
- Install (CLI): `npx get-skill add chauthehienp3c1/atlas-verify`
- Raw SKILL.md: https://api.skillmd.com/api/skills/chauthehienp3c1/atlas-verify/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: AI & ML
- Author: chauthehienp3c1 (https://skillmd.com/u/chauthehienp3c1)
- Updated: 2026-11-15
- Page: https://skillmd.com/skills/chauthehienp3c1/atlas-verify

---


# Atlas verify

A script can check that a citation points at something real and that a quote is verbatim. It cannot check that the quote *supports the sentence* it is attached to: that the
number was not changed, the direction not reversed, a cause not added, "can" not turned into "does". That is the gap a language model falls into most easily, because its
paraphrases read as faithful. This skill closes it with a second reader who has seen only the page and the cited text.

**Why the writer cannot be the checker.** The agent that wrote a page remembers what it meant, so it reads its own sentences charitably and fills gaps with what it already believes.
A checker with no access to that reasoning has only the page and the sources, which is exactly the position of the reader who will be misled. So: a separate agent, a fresh context, no hints.

## Before you start

1. The page must pass the script checks. Run `node scripts/lint-kb.mjs` and fix errors on the page first: a verifier's time is wasted on citations that do not resolve.
2. Every code repository the page cites must have a local clone registered in `.atlas/local.yaml`, because the packet shows the cited code. If the packet cannot be built, say which clone is missing and stop; do not skip the check.
3. You need to be able to start a separate agent with a fresh context (in Cursor: a subagent via the Task tool). If you cannot, **stop and say so**. Leave the page unverified (its banner will say "not done"); do not verify it yourself, and do not run
   `verify-stamp.mjs` with a report you wrote. An honest "not verified" is worth more than a self-signed pass.

## Steps

1. **Build the packet.** `node scripts/verify-packet.mjs kb/<page>.md` writes `.atlas/verify/<name>.packet.md`: the one-line summary, every cited statement with the cited source text beside it (cited lines marked, a few
   lines of context around them), and every diagram box and arrow with the statements that are supposed to back it. Note the packet path.
2. **Launch the verifier**: one new subagent, a capable model (a different model from the one that wrote the page is better if you can choose). Give it only this, with the packet path filled in:

   > Read `.cursor/skills/atlas-verify/verifier-brief.md` and follow it exactly. Your packet is `.atlas/verify/<name>.packet.md`. Write your report to `.atlas/verify/<name>.report.json`. You may read only the files the packet names. Reply with a two-line summary of your counts.

   Give it nothing else: not the conversation, not your notes, not other pages, not which statements you are unsure about, not how many problems to expect. Any of those lets your reasoning leak into the check.
3. **Read the report** (`.atlas/verify/<name>.report.json`). Do not edit it. For every item that is not `supported`:
   - A statement: **remove it**, or if the question it raises matters, **turn it into a question** on `kb/open-questions.md` ("the sources say X; they do not say Y; who knows?"). Do not soften the wording and keep it: a hedged claim that is still unsupported is still unsupported.
     Do not "fix" it by rewording to match the quote unless the reworded statement says no more than the quote does.
   - A diagram box or arrow: remove it from the diagram (and the cited table or list that names it, if that was the only backing).
   - The summary line: rewrite it to say only what the supported statements say.
4. **Run again from the top** (lint, `node scripts/sync-status.mjs`, a new packet, a **new** verifier agent) after any change, because the check applies to the exact page text. Repeat until every item is `supported`. If the same item keeps failing after three rounds, stop and tell the user which
   statement and why; do not argue it through.
5. **Stamp** only when every item is supported: `node scripts/verify-stamp.mjs kb/<page>.md --report .atlas/verify/<name>.report.json`. It re-builds the packet and refuses a report that is for different text, misses an item, or has any verdict other than `supported`. Then
   `node scripts/sync-status.mjs`, `node scripts/build-index.mjs`, `node scripts/lint-kb.mjs`.
6. **Tell the user** how many items were checked, what was removed or turned into questions, and that the page is **not yet human-reviewed** (a teammate runs `node scripts/review.mjs kb/<page>.md`; you never do).

## Work artifacts, and the completeness check

**The claims check works the same on a `work/` artifact**: `node scripts/verify-packet.mjs work/<ID>/<file>.md` and the same steps. A brief's "Proposed" section and an outcome's uncited "Expected" are not checked as facts, only that they are labelled and kept apart.

**The completeness check** is the other direction, for an artifact that shortens an original (`derived_from`). The claims check asks "does each line say what the original says?"; it cannot see what was left out. This asks "did dropping the rest lose a rule?":

1. `node scripts/left-out.mjs work/<ID>/<file>.md` and `node scripts/lint-work.mjs` first: the artifact must be lint-clean.
2. `node scripts/verify-packet.mjs work/<ID>/<file>.md --completeness` writes `.atlas/verify/<name>.completeness.packet.md`: the artifact, and every block of the original it does not cite, as B1..Bn.
3. Launch **one new subagent** (a different model from the writer if you can choose) with only this, the packet path filled in:

   > Read `.cursor/skills/atlas-verify/completeness-brief.md` and follow it exactly. Your packet is `.atlas/verify/<name>.completeness.packet.md`. Write your report to `.atlas/verify/<name>.completeness.report.json`. You may read only the files the packet names. Reply with a two-line summary of your counts.

   Give it nothing else: not the conversation, not what you think matters, not which blocks you are unsure about.
4. Read the report; do not edit it. For each block judged `missing`: add the line to the artifact with its citation, or ask the owner whether it is out of scope. A block that changes what is built, for whom, what is excluded or when it is done is not "not relevant", however it is worded. Do not reword the report or argue the block away.
5. After any change, run again from step 1 with a **new** agent. When no block is `missing`: `node scripts/verify-stamp.mjs work/<ID>/<file>.md --completeness --report .atlas/verify/<name>.completeness.report.json`, then `node scripts/sync-status.mjs`.
6. Tell the user how many blocks were judged and how many were covered, not relevant and missing, and that this is a second reader's opinion, not approval: the owner still reads the left-out list and approves.

A completeness pass means a separate reader found no block that changes behaviour, scope or acceptance and is absent from the artifact. It does not mean the artifact is right, and it cannot find something the original never said.

## What a pass means, and what it does not

A pass means: a separate reader found each statement stated by the cited text and each diagram element backed by a cited statement, at the time of the check, for this exact page text. It does not mean the page is true: the verifier can misjudge a paraphrase in either direction
(it will sometimes accept a subtle overreach and sometimes reject a correct statement); the source itself can be wrong (that is what the trust order and the findings register are for); and nothing checks what the page leaves out. The banner under each page says what was and was not done; do not
say more than it does.

Editing a page after the pass changes its hash, so the banner then says "changed since": run this skill again rather than leaving a stale stamp.

