Canon is the set of documents your AI output is grounded in — and cited against. Add your PRDs, specs, standards and exit criteria, and every generated case names the document and section it drew on. A cited case is checked in seconds. An uncited one has to be re-derived from scratch.
“Verify that the session expires after 30 minutes of inactivity.”
Plausible. Confident. Nobody in the room knows whether 30 minutes is your number or a number the model has seen a thousand times. Checking it means going and finding the spec yourself — which is the work the tool was supposed to do.
“Verify that the session expires after 15 minutes of inactivity.”
Same sentence, one chip. Hover it and you read the passage the model actually saw. The review is now a ten-second check against a document you can open — not a research task.
Canon is not somewhere you go to read. It is a source the rest of the product draws on, and there is no switch to remember — grounding is on unless you turn it off for a run.
Upload a spec, or pick a file already in your project's library — the same file, not a second copy. Canon never owns the bytes; it points at the library and indexes the text.
Extracting, then embedding, then ready. Only ready grounds anything, and the page says how many documents are actually live — because a list that looks full and grounds nothing is the failure worth catching.
Generation, release readiness and the application map all read from it and name what they used. One chip per document, however many passages a case drew on.
Most grounding hands a model the top few matching sentences. Ranked that way, section introductions win — they read like summaries — and the single most testable sentence in a document sits far down the list and never arrives. Canon finds the relevant documents and passes each of them whole, fanning your subject out across six axes a spec is actually written along: validation rules, errors and rejections, limits and defaults, lifecycle, step-by-step instructions, and the form and controls involved.
The promise is narrow and checkable: you can always find out where an answer came from, and you are told plainly when there was nothing to answer from.
A PRD, an API contract, an accessibility standard, the exit criteria you sign releases against. Once a document is admitted, it is what the AI writes against — not a general idea of how systems like yours behave.
A generated case carries a chip per document it drew on. Hover it and you see the exact passage the model read — after truncation, so you are looking at what it actually got, not a flattering longer version.
Ask Canon runs the same retrieval that grounds a run and shows you the raw passages and their scores. No model in between, nothing created. If a topic comes back empty, you learn it in ten seconds instead of after reviewing forty drafts.
A document that failed to parse is worse than a missing one, because the list still looks full. So ingestion state is the headline: pending, extracting, embedding, ready or failed — with the parse error printed on the row, verbatim.
Uploaded text and even filenames are treated as material describing a system to test. A spec containing “ignore previous instructions” is read as a spec describing a system, not as a command.
The readiness summary on a release is judged against the exit criteria you wrote down, and cites them. Without Canon a model supplies a generic standard from its own priors — “80% pass rate looks healthy” — which is exactly what a sign-off should not rest on.
Canon has one page of its own. Its value is everywhere else.
Both stages of a run are grounded — the coverage map that decides what to test, and the steps written for what you picked. Gaps carry citations too, because a gap is only actionable if you can open the document that needs the missing sentence.
The AI test case generator →The AI summary on a release judges against your documented exit criteria and names them. A reviewer can open the standard the call was made against instead of taking the number on faith.
Releases & sign-off →Atlas reads Canon to propose the product's areas, screens and routes, and every proposed node carries the citations it was drawn from — so you check a suggestion against the document that implied it before accepting it.
Atlas — the product map →The PRD, the API contracts, the design docs — whatever states how this product is supposed to behave. Most documents describe one thing, so this is the right default.
Test strategy, accessibility and security standards, regulatory requirements. A run inside a project reads both levels — a tester asking about login wants the login spec and the accessibility standard.
A grounding feature that oversells itself is worse than none, because you stop checking. So here is where it stops.
Eight document types, supplied by you. There is no crawler, no Confluence connector, no URL box. What you admit is what it knows.
A PDF with no text layer fails loudly with the reason. Reading text off page images would put unreliable passages in the corpus and then cite them as authority. OCR is a deliberate non-goal.
Replace the underlying file and the index does not follow. Re-index is one click and it is yours to press — nothing here silently reinterprets a document you have not looked at.
A spec that says “users may edit shared steps” gives a test case nothing to check. Canon surfaces that honestly rather than inventing the missing outcome — and Ask Canon shows you which topics are thin before you generate.
Ask Canon returns raw passages and scores, not an answer. It exists to explain retrieval, and a polished summary would hide the exact thing you came to check.
Someone in the review reads a generated case that asserts a 30-day retention window and asks the question that stops every meeting. Without a citation, the answer is a promise to go and look. With one, it is a chip: Data retention policy · §2 — opened, read, confirmed, and the meeting carries on. Two minutes later the same person asks about deletion, finds nothing in Canon on it, and now knows something more useful than a test case: that behaviour is not written down anywhere.
Canon says what your product promises. Atlas shows what it is made of — the areas, screens and routes, what depends on what, and which parts no test reaches. Between them, an AI answer has both a source and a shape.
Every feature is free while Hawzu is in early access — no credit card required.