K13 - Ai General Response Standard

Version: 2.2.0 Status: Open standard, published License: CC BY 4.0 (specification text) Author: Random Knights, LLC, ORCID https://orcid.org/0009-0006-5066-1693 Cite as: Random Knights, LLC (2026). K13 - Ai General Response Standard, version 2.2.0. CC BY 4.0. https://github.com/random-knights/standard Scope: Model-agnostic Canonical text: K13.md in https://github.com/random-knights/standard

Kindergarten through 12th grade, plus college. That is K13. Anyone should be able to read it.

Canonical text and mirrors

This file is the standard. K13.md in the random-knights/standard repository is the one authoritative text, and it is the only place a change to K13 is made.

Every other copy is a MIRROR. A mirror is a copy kept somewhere else for convenience: in an application that renders the standard, on a documentation site, inside a published package, in an agent's instruction set. A mirror has no authority. When a mirror and this file disagree, this file is right and the mirror is stale, no matter which one the reader found first.

Three consequences follow:

A change lands here first. Editing a mirror does not change K13. It creates a disagreement, and the disagreement is a defect in the mirror.
A mirror states the version it carries. It carries this header, which means it carries the canonical pointer too. A reader who finds a mirror can always tell which version they are holding and where to check it.
A mirror is checkable, so it should be checked. The canonical text is published as a fixed artifact at a stable address, and the current version number is published as machine-readable data at another. A mirror that is never compared to either is a copy nobody is verifying, and that is the condition this section exists to end.

The published artifacts are these:

What	Where	Use it to check
the canonical text, byte for byte	`standard.rand0m.ai/k13/v1/K13.md`	that a mirror's bytes match the standard
the current version, machine readable	`standard.rand0m.ai/versions.json`	that a mirror is not a version behind
the text inside a published package	`@randomknights/k13`, at `K13.md`	the same, for a consumer that installs rather than fetches

An implementation that mirrors this text SHOULD compare its copy against one of them on every change, and MUST NOT present a mirror as the standard.

The standard at a glance

K13 is thirteen steps, run in order, every time. Every time does not mean every step takes real work: on a short reply the steps take a second each and the six passes come out identical, which meets the standard rather than skipping it (see "Short work: the passes converge"). The named rules are written into the steps that carry them, so meeting the steps IS meeting the rules. There is no optional mode.

Scope: when K13 applies

K13 is written for work that produces a REPORT. A report is a piece of writing that stands on its own, that someone will read after the work is finished, and that a reader has to trust without having watched the work happen.

K13 applies to:

A long-running task summary, the writeup an agent or a person leaves behind after hours of work.
An investigation or audit writeup, where the reader was not present for the checks.
A lane or release report: what shipped, what was verified, what is still open.
A standards or methodology document, including this one.
Any response from a high-reasoning model running unattended, auto mode included, because nobody is there to ask a follow-up question.

K13 is NOT a format for:

A one-line answer. "The file exported" is a complete response.
A conversational reply, the back and forth of working something out with a person who is right there.
A tool call, or any machine-to-machine message.

Applying the thirteen steps and the six response levels to a short exchange is a misapplication of the standard, not a stricter reading of it. A short reply meets K13 by being accurate and plain. When the work is small the passes are already identical, so writing them out separately adds length and no information (see "Short work: the passes converge").

The thirteen steps

Verify state. Real sources only. No guessing, no plausible defaults.
Capture the cost before drafting anything else. Rule carried here (cost tracked, AiEDs v2): every AI response records its cost to the shared AiEDs store under the v2 model. The AI logs it. The human never copies numbers by hand. If a tool cannot report usage, say so plainly instead of guessing.
State the outcome first, then the method. Plain sentence, short words. What happened, not effort. Rule carried here (human readable): short sentences, plain words. Say the thing, then explain it. Lead with what it means for the person, not how it was built. No wall of jargon. This rule governs every writing step from here through step 12.
Flag every roadblock. Blocked, skipped or partial, named plainly, not buried in prose.
Translate the cost into meaning, not raw figures. Example: "8 grams of carbon, about 3 hours of one tree's work."
Name the owner action. Exact click, exact command. Never "let me know" when a real action exists.
Pull the next-command template. Model and effort included. Match the situation to a template in the command template library (see "Command template library" below), filled in exactly, ready for any agent on any model to paste and run cold.
Check the humor. Sparse, honest, off entirely on safety, money or loss. The humor section below is the law here: its rules and its off-limits list.
Draft the juice box pass. K-5. No jargon at all. One idea per sentence. Rule carried here (response level): steps 9 to 12 are this rule in action, and juice box is the default level. A picker opens on juice box when the reader has not chosen a level, and a report rendered with no level selected renders juice box. Six passes, one ladder: juice box, soda pop, energy drink, black coffee, loose leaf, yerba mate. A reader picks a level and the answer is written at that level, never rewritten from another one. Spelled plainly, no numeric swaps: the swaps mark AI bot identity, and K13 is a published standard, not a bot.
Draft the soda pop pass. 6-8. One new term at a time, explained as it appears. Rule carried here (response level): the middle school pass. Middle school and high school are different levels, so they are different passes.
Draft the energy drink pass. 9-12. Real terms, defined once. Rule carried here (response level): the high school pass.
Draft the black coffee pass. College. Full precision, look it up yourself. Rule carried here (response level): the top of the school ladder. Full precision is part of the rule, not an escape from it. 12.1 Draft the loose leaf pass. Masters. Architecture level: how the parts fit together, what the cross-system scope is, and what the confidence bounds on the claim are. 12.2 Draft the yerba mate pass. Doctorate. Formal level: the methodology, the sample, how far the result generalizes, the questions this work raises but does not close, and the limitations of the inspection.
Run the gate. No em dashes. Every claim checked. All six passes agree. Fix before sending. Rule carried here (no em dashes): use periods, commas, colons, or parentheses. This applies to the response and also to code comments, docs, commit messages, and public copy. The gate fails on a single em dash. An en dash fails the same way. A double hyphen used as a dash is forbidden too: "--" is a surrogate for the character the rule bans, so it breaks the rule rather than working around it. Use a comma, a colon, or a new sentence. The ban is on the dash as punctuation, not on every pair of hyphens: a command line flag such as --json and a markdown table rule such as | --- | are not dashes and are not what this rule is about.

Short work: the passes converge

For short work the six passes converge. "The file exported" is the juice box answer and the yerba mate answer at once. When the passes come out identical, step 13 passes on sight. That is the standard being met, not skipped.

So a one-line reply still runs all thirteen steps. At that size most steps take a second. The steps are a checklist, not a length requirement, and they never force a short answer to become a long one.

The response levels

A response level is the same answer, adjusted to the reader's preference: from a quick, easy read at juice box to a full deep dive at yerba mate. The six levels form a ladder, one rung for each pass in steps 9 to 12.2.

A PASS is the written text of one answer at one response level. The six levels are six rungs; the six passes are the six texts written at them. Steps 9 to 12.2 each draft one pass. Where this standard says "a reader picks a level" it means which pass is shown. Where it says "all six passes agree" it means the six texts carry the same facts. Both words are normative and neither replaces the other: a level is what a reader chooses, a pass is what is written for it.

Each level carries a normative icon, given here as a Unicode codepoint so this document stays ASCII. An implementation renders the glyph.

Level	Grades	Step	Icon
juice box	K-5	9	U+1F9C3 BEVERAGE BOX
soda pop	6-8	10	U+1F964 CUP WITH STRAW
energy drink	9-12	11	U+1F9CB BUBBLE TEA
black coffee	College	12	U+2615 HOT BEVERAGE
loose leaf	Masters	12.1	U+1FAD6 TEAPOT
yerba mate	Doctorate	12.2	U+1F9C9 MATE DRINK

The icon is normative but it only decorates. The level NAME is what identifies a level, and an implementation must never let the glyph be the only thing carrying it.

Text alternative. Every rendered glyph MUST have a text alternative that is the level name (or, when the interface shows a localized label, that label; see "Names, identifiers and labels"). It is never the Unicode character name: "soda pop" is correct, "cup with straw" is not. Two cases cover every use:

The name is written visibly beside the glyph. The glyph is then marked decorative to assistive technology (aria-hidden="true" in HTML), so a screen reader says the name once, from the visible text, and not twice.
The glyph stands alone, for example on a compact picker tab. It then carries the name as its accessible name (role="img" with aria-label="soda pop" in HTML, or the platform's equivalent).

A screen reader therefore reads one thing for each level: the level name, then the grades when they are shown, then the selected state when the control is a picker, for example "soda pop, 6-8, selected". It does not read the character's Unicode name, and it does not read a glyph and its name as two items. A control that selects a level is named by the level, never by the glyph alone.

A response level changes how the answer is written, not what it says. The ladder is not a detail ladder, where higher levels carry more facts. All six normative passes carry the same facts, the same figures, the same verdicts and the same confidence; only the sentences change. A reader who picks juice box is not given less of the answer, and a reader who picks yerba mate is not let in on anything the others were not told. If a higher level states a figure a lower level does not, or states a different one, the passes disagree and the report fails step 13. An implementation that adds figures as the level rises has built a detail ladder, and a detail ladder fails step 13 by construction, no matter how carefully each pass is written.

Level identifiers

Each level has one machine-readable identifier, for stored choices, data files, APIs and receipts. The identifier is the level name in lowercase with its spaces replaced by underscores:

Level	Identifier	Stored as before 2.2.0
juice box	juice_box	same
soda pop	soda_pop	vending_machine
energy drink	energy_drink	same
black coffee	black_coffee	same
loose leaf	loose_leaf	same
yerba mate	yerba_mate	same

An implementation SHOULD use these identifiers wherever it needs a machine-readable level, in interchange and in storage. They are fixed from 2.2.0: a later version that renames a level keeps its identifier, as 1.1.0 did, and says so here.

One exception is written down. Since 1.1.0, implementations that already persist a reader's choice store soda pop as vending_machine, because renaming the stored value would silently reset every saved choice. That legacy identifier stays valid. An implementation that stores it SHOULD keep storing it and map it to soda_pop at its boundary, when it writes interchange data or reads data from another implementation. It MUST NOT rename a stored value, or the key or box the choice is stored under, to match this section: a preference box named reading_level_prefs keeps that name, though this standard no longer calls the levels reading levels.

Names, identifiers and labels

Names and identifiers stay English. The six level names and the six identifiers are fixed strings. A level name or identifier MUST stay the English string wherever it is written for another system or cited as the name of a level, in every language.

Labels may be localized. A label is the word or phrase an interface shows a reader for a level. A localized label maps back to exactly one level name. The glyph is paired with the level by its identifier, not by the translated words, so translating a label never changes which glyph or which level a reader has.

The levels file

The table in "The response levels" and the identifiers above are also published as a data file, k13-levels.json, at https://standard.rand0m.ai/k13/v1/k13-levels.json. It is generated from this document when the site is built and is never edited by hand. If the file and this document disagree, this document is right and the file is stale. It lists each level's name, identifier, grades, step, codepoint and Unicode name, the stored-before-2.2.0 identifier where one exists, and the default level.

The default level

Juice box is the default response level. It is the level a picker opens on, the level a report renders when no level has been selected, and the level an agent writes at when the reader has not said which one they want. It is the starting point, not a judgment about the reader: anyone can pick another level at any time, and the choice is theirs to keep.

What the default changes:

A picker opens on juice box, and the juice box pane is the one shown first. Before 2.2.0 it opened on energy drink.
A report is always written at all six levels, so the default changes only which level is shown first, never what the report contains.
A reader who has already picked a level keeps it. A remembered pick always wins over the default, and the default applies only when nothing has been remembered. Changing the default must never reset a saved choice, and the stored identifier of a level is not renamed to make it so.
A new reader, a signed-out reader, and any reader who cleared their saved choice all start on juice box.
An agent with no stated level for its reader writes the answer at juice box. An agent that has been told a level, or has a remembered one, uses that.

Extending the ladder

The six passes above are normative. All six carry step numbers, all six must be written, and all six must agree at step 13.

An implementation MAY define expert levels above yerba mate, for readers with an assumed specialism narrower than a doctorate. Such levels are NOT among the six response levels. A response level changes how plainly one audience is written for; a level above yerba mate assumes a different audience entirely, one that already holds a specialism. So any such level carries no step number, does not change the count, and the standard remains thirteen steps with steps 9 to 12, plus 12.1 and 12.2, as the six passes, one each.

On the numbering: the thirteen steps count kinds of WORK, not levels of audience. Drafting a pass is one kind of work, so the ladder lives inside the drafting block at steps 9 to 12 rather than spreading into new top-level steps. Loose leaf and yerba mate are the step 12 drafting work written for a reader who already holds the domain, which is why they are numbered 12.1 and 12.2 and not 13 and 14. Numbering them at the top level would have pushed the gate to step 15 and made the name K13 false.

An implementation that offers levels above yerba mate must still write one honest answer at the level asked for, and must still make all six normative passes agree at step 13.

The machine gate

Step 13 is checkable by a machine. An implementation that ships K13 reports runs these six checks before a report ships:

Number agreement. Extract every number from every normative level. Any figure that appears at one level and disagrees at another fails the gate. A figure that appears at one level and is absent from another is the detail ladder described above, and fails too.
Every graded value present at every level. Verdict, confidence and provenance are graded values. A level that carries the verdict but drops the confidence is not the same answer.
No untraceable figure. Every number in the report traces back to run data. A number that cannot be traced to what was actually run is a guess wearing a decimal point, and step 1 already forbids it.
No em dash, no en dash, no double-hyphen surrogate, anywhere in the report.
The same tile set, in the same order, at every level. A level that adds a tile the others lack, or omits one they have, fails. See "Structural invariance" below.
No evidence block without a rendered result, and no result without the command that produced it. See "Evidence blocks" below.

A seventh check applies to the "What's next" tile: a model name there is a failure unless a cited role-to-model mapping resolves it. The standard asks for a role and an effort, which are vendor-neutral; a bare model name is an implementation's preference wearing a requirement's clothes.

A gate that has never failed is not a gate. Prove it fails: plant a disagreement, a missing graded value, an untraceable figure, a dash, a tile present at one level and missing at another, and a command with no result. Watch each one go red, then remove them. An implementation that cannot show its gate failing has an assertion it has never tested, not a gate.

One reference implementation renders each normative level from a single record of run facts through a statement table, where every statement declares the slots it fills and every level's variant must use exactly those slots. Number agreement then holds by construction rather than by inspection, because there is only one place a number can come from. That is one way to do it and not the only way; what the standard requires is the six checks, not the design.

Test vectors

The @randomknights/k13 package ships a passing vector and a failing vector for each of checks 1 to 6, in its vectors/ directory, and runs the checker over them. A passing vector is a six-level report the check must accept. A failing vector plants exactly one defect the check must name. They exist so a gate does not have to be built to find out what "plant a disagreement" means.

A vector illustrates a check and does not widen it. The numbered list above is the rule. Where a vector and the list disagree, the list is right and the vector is a defect to fix. The checks the package cannot run without outside data are given the data in the vector (check 3 is given the run figures).

Stating conformance

A report or an implementation MAY state conformance in one line, so claims are comparable:

conforms to K13 2.2.0, six response levels, gate checks 1 to 6

The statement names the K13 version it was checked against, the count of response levels, and the gate checks that were run and passed. If fewer than all six ran, the statement names the ones that did, for example "gate checks 1, 2, 4 and 5". A statement never claims a check that was not run: step 1 applies to the statement like any other claim.

The report template

A conforming K13 report carries these twelve tiles, in this order:

A header strip: what this report is, the subject, the date, the gate badge.
A one-sentence finding. The outcome, not the method.
A verdict row with its gate string. Pass and fail is rarely a boolean in real work, so the verdict carries the exact gate string it was given.
How it fits: what plan, lane or larger effort this work belongs to, what it unblocks, and what preceded it.
An environment card: what was run, where, at what version or commit.
A checks table: the check, how it was verified, the result.
Evidence blocks: every command or query with its real rendered result.
Discrepancies.
What's next: concrete continuations the reader can take.
Owner actions, written as exact commands.
What was NOT done, and why.
The AiEDs disclosure for the work the report covers.

Every one of these is present in a shipped report, at every normative level, in this order. A tile with nothing to report says so in one line. It is never dropped in silence, and it is never dropped from one level and kept at another. See "Structural invariance" below, which is the rule that makes this list a shell rather than a suggestion.

Two of the twelve are new in 2.0.0 and are worth stating on their own.

How it fits

A report that says what happened but not what it was part of is legible only to the person who dispatched the work. This tile says which plan item, lane or larger effort the work belongs to, what it unblocks, and what preceded it. It is what lets a reader who has never seen the dispatch understand why the work was done at all.

What's next

Continuations the reader can take. These are distinct from owner actions: owner actions are the things only the owner can do, and What's next is everything else. The wording varies by level; the tile and its position do not.

When a continuation exists, this tile carries three things:

The ROLE of the next task, chosen from the implementation's own published role list, with a one-line justification against that list's stated criteria. The role is the judgement. It is stated so that a reader can disagree with it.
The EFFORT, or reasoning level.
A paste-ready COMMAND in the implementation's dispatch shape, complete enough to execute cold.

The standard requires the role and the effort. It does NOT require, and does not accept, a model name in their place. A named model is vendor-specific and K13 is vendor-neutral. An implementation MAY resolve a role plus an effort to a named model from its own published mapping, and when it does it MUST cite that mapping beside the name, so the resolution is checkable rather than a preference. This closes an obvious bias: an agent naming its own successor otherwise names itself, and inflates.

"No next step, this work is complete" is a valid answer, and it must always be available. A report never manufactures a continuation to fill this tile. It states completion and says why.

This tile is the artifact form of step 7, which already requires pulling a command from a template library rather than writing one from memory.

The reference templates

The reference templates live in this repository, at templates/temp1ate.md and templates/temp1ate.html. They are one rendering, not the requirement. An implementation may use its own markup, its own styling and its own file format so long as every tile above is present, in this order, at every level, and the machine gate passes.

The templates are Apache 2.0, because they are a reference implementation and are meant to be forked without attribution friction. The REQUIREMENT, the ordered tile list above, is part of this document and is CC BY 4.0.

Structural invariance

The report SHELL is identical at every level: the same tiles, the same order, the same positions, the same count. Only the REGISTER changes: the finding sentence, the narrative prose, and the wording of the actions. Data cells are byte-identical across levels. Prose cells vary.

A level that adds a tile the others lack, or omits one they have, fails the gate.

The 1.1.0 reference template taught the opposite, and this rule exists because of it. That template put a checks table only at energy drink, a query block only at black coffee, and open questions only at yerba mate. An author following it faithfully produced a report where the higher the level, the more there was to see. That is the mechanism behind the detail-ladder drift observed in the field: not a careless author, but a template whose shape said the ladder was about how much you get rather than how it is said.

Under this rule every level carries every tile, the query block and the checks table included. A juice box reader sees the same evidence an expert sees, explained differently. That is the ladder working, not a category error.

A reader switching levels should see the same report in different words, not a different report. In a rendered implementation this has a visible consequence: the page does not reflow when the level changes, because every level occupies the same boxes. Reserve the space rather than letting the content set it.

Evidence blocks

Any query, command or script used as evidence appears in a code block WITH its real rendered result beside or below it.

A query with no result fails the gate. A result with no query fails it too: a figure a reader cannot trace to the thing that produced it is exactly what the machine gate's third check exists to catch.

Results are never fabricated, never illustrative, and never quietly shortened. If a result is too large to show, show a stated subset and say what was cut. "First 20 of 4,312 rows" is a result. A trimmed block presented as the whole thing is not.

Evidence blocks obey structural invariance like every other tile: if a query appears at one level it appears at all six. The command and its result are data, so they are byte-identical at every level. What changes is the sentence around them.

One fact, six ways

The rule that all six passes carry the same facts is easy to agree with and hard to hold. This section shows one real fact written six times. Read the figures down the page: 2.0.0, 1.1.0, six, four. They do not move. The verdict does not move, the confidence does not move, and the provenance does not move. The sentences do.

juice box. Six of our copies of the rules are old. We are sure about that, because we opened each one and read its version number. The new rules are version 2.0.0 and have six levels. The old copies are version 1.1.0 and have four levels. We looked in four places, so there may be an old copy we did not find. We are less sure about that part. The old copies need to be replaced with the new one.

soda pop. K13 now has six response levels. It used to have four. The change shipped in version 2.0.0. We keep copies of K13 in other places, and six of those copies are still on version 1.1.0, the old one with four levels. A copy is a file that is supposed to match the original. These six do not match, so they have to be updated. We are highly confident of that, because we read the version number in each copy ourselves. We searched four repositories, and an unsearched one could hold another stale copy, so we are only moderately confident that six is the whole count.

energy drink. K13 2.0.0 promoted loose leaf and yerba mate from reserved names to normative passes, taking the ladder from four levels to six. Six downstream copies are still on 1.1.0: a workspace root copy, an agent skill file, an application's documentation copy, the constant that mirrors it, and the documentation site's copy of the standard and of its skill file. Each is a place a reader or an agent can pick up the old four-level ladder and believe it is current. Confidence that all six are stale is high, because each was read directly at its version line. Confidence that six is the complete count is moderate, because the search covered four repositories and an unsearched one could hold another.

black coffee. The 2.0.0 revision promoted the reserved expert names, loose leaf and yerba mate, to normative passes, moving the ladder from four levels to six without changing the step count. Six downstream artifacts remain pinned at 1.1.0. The consistency check that exists pins a rendered constant to a repository-local copy, not to the standard, so it passes while the copy it pins is a version behind. Fan-out is therefore a manual step today. Confidence that all six are stale is high, since each was read directly at its version line. Confidence that six is the complete count is moderate, since only four repositories were searched.

loose leaf. The standard has one source and several mirrors, and the mirror chain is where the six stale artifacts come from, each still at 1.1.0 while the source is at 2.0.0, four levels against six. The root copy is not in any repository, so no continuous check can diff against it; the application-side guard gates a constant against a repository-local text file, which makes the guard's scope the repository rather than the standard. That scope choice is the architectural cause: every mirror is verified against its nearest neighbor and none against the source, so a version bump at the source propagates no steps and reports green the whole way. Confidence that all six are stale is high, because each was read directly at its version line. Confidence that six is the complete count is moderate: it covers the four repositories searched, and an unsearched repository could hold another.

yerba mate. Method: the source was read at the default branch of the standard repository and its version line and ladder table recorded; each candidate mirror was then read at its own default branch, or on disk where it is not under version control, and its version line recorded: 2.0.0 at the source, with six levels, and 1.1.0 at each of the six stale mirrors, with four levels. The sample is the four repositories known to carry K13 text plus the workspace root, which is a convenience sample of known mirrors, not an exhaustive search. Confidence that all six are stale is high, because every version line was read directly. Confidence that six is the complete count is moderate, because the sample is a convenience sample. The result generalizes to any standard mirrored by copy rather than by reference: transitive verification between adjacent mirrors is not verification against a source, and a green chain of such checks carries no information about source agreement. Open questions this raises and does not close: whether the root copy should be moved into a repository so it can be checked at all; whether the mirrors should be generated at build time instead of committed; and whether the existing version fan-out should own K13 as it owns the other standards' version numbers. Limitations: the inspection read version lines and ladder tables, not full document diffs, so a mirror carrying the 2.0.0 version line with 1.1.0 body text would not have been caught by this pass.

Read the six again as a set. Every pass carries the same four figures: version 2.0.0, version 1.1.0, six, and four. Every pass carries the same verdict (the six copies are stale), the same confidence (high that they are stale, moderate that six is the whole count) and the same provenance (each version line was read directly). No pass introduces a figure another lacks, and no pass withholds one. That is what the levels are for. A version of this example where juice box said "some copies are old" and yerba mate said "six copies" would be a detail ladder, and would fail step 13 on the first check of the machine gate.

This example passes its own gate. The @randomknights/k13 package reads these six passes out of this document and runs machine gate checks 1 and 2 on them in its tests, so the example cannot drift into a detail ladder without a test going red.

How to hit any response level

One idea per sentence.
Define a term the first time you use it. Example: "efuse, a one time hardware switch."
Prefer the short word. Use "before" not "prior to." Use "use" not "utilize."
Numbers get context. "8 grams of carbon, about 3 hours of one tree's work."
Cut hype words: revolutionary, seamless, game changing, cutting edge, unlock.
If you must use a technical name, keep it and explain it once. The facts stay at full strength; only the sentence gets simpler.

What K13 does not mean

It does not mean short. A long answer can be K13 if every line is clear.
It does not mean vague. Precision is part of being readable.
It does not mean no code. Code blocks are fine. The words around them follow K13.
It does not mean cheerful. Bad news gets said plainly too.

Humor, the signature layer

Humor is part of the standard, not decoration. It runs as step 8, after the substance is set, never instead of it.

Where it comes from

We are cave men working with UFOs.

AI is faster and smarter than any of us. What we have that it does not is the messy human part: connection, emotion, being understood by another person. That gap is both the joke and the point.

People and companies are sprinting toward something they have not stopped to understand. Adopting first, thinking later, sometimes breaking things on the way. Saying that plainly, without hedging and without doom, is where the humor lives.

The shape of it

Blunt. We call things as we see them. Dry, specific, self-aware. Understated, not zany. No exclamation marks, no puns for their own sake.

The best joke is the accurate one. The strongest line in the product is a fallback message: "no surf read this far from the coast." It is funny because it is exactly true, specific about why, and refuses to fake a number. Same with "coming soon: ski (needs snow depth and the avalanche.org danger feed)." It names the real blocker. The humor is the candor.

So before writing a joke, check whether a more specific true statement is already funnier. It usually is.

Rules

Clarity first. If the joke makes the sentence harder to follow, cut the joke.
Once per response, not once per paragraph. Sparse humor reads as confidence. Constant humor reads as nerves.
We are the butt of the joke, never the reader. We can be blunt about the industry and about ourselves. We never make light of the person's situation, skill, or choices.
Never attach humor to a number. The figure stays clean. Put the color in the sentence beside it.
No hype words in a costume. "Wildly seamless" is still hype.

Where humor is off

Hard stops. In these cases, write it straight:

Safety. A SEVERE verdict, dangerous wind, a heat warning. Someone may act on it.
Anything that cost the person something. Lost data, a failed save, a charge, downtime.
Security and privacy. Key exposure, breaches, permissions.
Money. Billing, pricing, refunds.
Legal and tax.
When the person is frustrated. Read the room and match it. Do not try to lighten it.
Errors the person did not cause.

Absence of humor is not a failure of voice. Restraint is part of the voice.

Not humor, a convention

Numeric letter swaps (knight1y, uti1ity, 1aunchpad, scient1st) mark AI. They tell a user they are talking to a bot, not a person. That is a signal, keep it consistent, and do not mistake it for a joke.

Agent format rules that ride with K13

Ground truth or say you do not know. Never present a guess as a fact.
No demo data, ever. A plausible default is not a real reading. Absence is honest.
Name the owner action. If a human must click, say exactly what and where.
Report state, not effort. "Merged at SHA x" beats "I worked hard on this."
Flag the conflict. If instructions disagree, stop and show both.

Self check before sending

Ask five questions:

Did I log the cost?
Could a 5th grader follow the juice box pass?
Any em dashes?
Is every claim something I actually checked?
If there is a joke: is this a topic where humor is allowed at all, and does the sentence still work with the joke removed?

Command template library

An implementation keeps ONE canonical, version-controlled command template, and every agent dispatch is built from it. Where that file lives is the implementation's business. What matters is that there is exactly one of it, that it is version-controlled rather than pasted from memory, and that any surface showing it reads the same content rather than a copy that can drift.

A dispatch command carries these fields, in this shape:

task
repo
model
effort
scope
constraints
verify steps
stop condition

That shape is the point. A command written for one model and picked up by a different model on a different day still lands in the same form, so it can be pasted and run cold.

Changelog

Terminology: through 2.1.0 this document called the levels "learning levels" (in the section heading and the "Rule carried here" labels) and "reading levels" (in prose). From 2.2.0 they are "response levels". Entries below keep the words in use when they were written.

2.2.0

Wording, the long name, and the default level. A 2.1.0 report conforms to 2.2.0 unchanged, because every report already carries all six levels. No step number, count, level name, reserved name or icon changes. One implementation rule changes: the default level, described below.

The long name is "Ai General Response Standard". The short name K13 is unchanged. It was "AI Response Standard".
The default response level is now juice box. It was energy drink. Step 9 now carries the default rule that step 11 carried, and the new section "The default level" states what it means for pickers, reports, agents and saved choices. A remembered pick still wins, and no stored level identifier is renamed, so no saved choice resets.
The six levels are named "response levels": the same answer, adjusted to the reader's preference. "Learning level" and "reading level" are retired as names for them, because the levels do not teach and do not rate the reader.
Section "The learning level ladder" is now "The response levels", and "How to hit any learning level" is now "How to hit any response level". The anchors #the-learning-level-ladder and #how-to-hit-any-learning-level become #the-response-levels and #how-to-hit-any-response-level. The "Rule carried here" labels at steps 9 to 12 now read "(response level)".
New heading "The standard at a glance" over the opening paragraph that sat under "Canonical text and mirrors".
Step 7 pointed at docs/command-templates.md, a path that is not in this repository. It now points at the "Command template library" section.
Plainer wording in the opening, scope and levels sections: repeated explanations removed and each term defined once. No requirement was changed by this.
"One fact, six ways" now states the version numbers its closing paragraph says every pass names.
"One fact, six ways" is rewritten so it passes machine gate checks 1 and 2 itself. It had a figure at two levels only ("four repositories") and a confidence statement at one level only, so by its own gate it was not clean. Every pass now carries the same four figures, the same verdict, the same confidence and the same provenance. The package's tests read the six passes out of this document and run checks 1 and 2 on them.
New section "Level identifiers": a machine-readable identifier for each level (juice_box and so on), as a recommendation, with the 1.1.0 exception written down: soda pop persists as vending_machine. The stored legacy box name reading_level_prefs is untouched. Names and identifiers stay English; labels may be localized.
A PASS is defined once, as the written text of one answer at one response level. Both "pass" and "level" stay normative.
Every rendered glyph must have a text alternative: the level name, never the Unicode character name. How a screen reader reads a level is stated.
New subsection "Test vectors": a passing and a failing six-level vector per machine gate check, shipped in @randomknights/k13. A vector illustrates a check and the numbered list wins on disagreement.
New subsection "Stating conformance": an optional one-line statement, "conforms to K13 2.2.0, six response levels, gate checks 1 to 6".
New data file k13-levels.json, generated from this document at site build time, so the ladder has one source.
The package checker implements machine gate checks 1, 2 and 3 for the passes of a report, and a glyph text alternative check for HTML. Checks 1 to 6 of the gate itself are unchanged; this is implementation, not a new rule.
Counts of the capitalized normative keywords, each counted on its own with "must not" apart from "must": must not 2 (was 1), must 3 (was 1), should 3 (was 1), may 3 (was 2). The additions are one must (glyph text alternative), one must not (renaming a stored value), one must (names stay English), two should (identifiers, the legacy mapping) and one may (conformance statement).
Deferred, not in this version: worked examples for each of the twelve tiles (not just the finding sentence). They risk reading as a detail ladder and are a large body of text; this is recorded here so the question is not lost.
Kept as is by owner decision: the phrase "deep dive" in the definition of a response level, the education grade labels in the ladder table, and juice box as the default level.

2.1.0

Additive. A 2.0.0 report conforms to 2.1.0 unchanged, and no rule changes.

New section "One fact, six ways": one real fact written at all six normative levels, so an implementer can see the reading ladder and the detail ladder side by side rather than inferring the difference from the prohibition. The rule it illustrates is unchanged. The example was written because the field drift 2.0.0 describes kept recurring in implementations that had read the rule and agreed with it.
New section "Canonical text and mirrors", and a "Canonical text" line in the header. This file is the one authoritative text; every other copy is a mirror with no authority, a mirror states the version it carries, and the published artifacts a mirror can be checked against are named. Nothing here is new policy: the repository already served the canonical text and the version data at fixed addresses. What is new is that the standard says so in its own text, so a mirror carries the statement that it is a mirror.

2.0.0

BREAKING. A 1.1.0 report with four levels does not conform to this version.

All SIX levels are normative. Loose leaf and yerba mate are promoted from RESERVED to required, they carry step numbers 12.1 and 12.2, and they get the same definition treatment the other four get. Every "four passes" in this document is now six.
The ladder is stated to be a READING-LEVEL ladder: all six passes carry the same facts, figures, verdicts and confidence, and an implementation that adds figures as the level rises has built a detail ladder, which fails step 13 by construction.
New section "Scope: when K13 applies". K13 is for work that produces a report. Applying the thirteen steps to a one-line answer, a conversational reply or a tool call is a misapplication, not a stricter reading.
New section "The machine gate": the six checks an implementation runs before a K13 report ships, and the rule that a gate which has never failed is not a gate.
New section "The report template": the ordered twelve-tile list a conforming report carries, plus a pointer to the reference templates now in this repository at templates/.
Two of those tiles are new. "How it fits" says what plan or lane the work belongs to, what it unblocks, and what preceded it. "What's next" carries the role, the effort and a paste-ready command for the continuation, never a model name unless a published mapping is cited, and "No next step, this work is complete" is always a valid answer.
New section "Structural invariance": the report shell is identical at every level and only the register changes. The 1.1.0 template taught the opposite by putting the checks table, the query block and the open questions at one level each, which is the mechanism behind the detail-ladder drift observed in the field.
New section "Evidence blocks": every command or query appears with its real rendered result, results are never fabricated or quietly shortened, and evidence is invariant across all six levels.
The dash rule at step 13 now forbids "--" as a dash surrogate, and names the replacements: a comma, a colon, or a new sentence.
Step 11 names energy drink as the level a picker opens on when the reader has not chosen one.
The step numbering is restated rather than extended: the standard is still thirteen steps, and the two new passes are numbered inside the step 12 drafting block.

Migrating from 1.1.0

A 1.1.0 report has four levels. To conform to 2.0.0 it adds a loose leaf pass and a yerba mate pass carrying the same facts, the same figures, the same verdicts and the same confidence as the other four. Nothing in the four existing passes has to be rewritten: if they already agreed with each other, they already agree with the two new ones once the new ones are written from the same facts. An implementation that treated loose leaf and yerba mate as reserved names now writes them.

Version 1.1.0 remains citable as published. It is not withdrawn, and a report that states it conforms to K13 1.1.0 is making a true statement about 1.1.0. Cite the version you adopted.

1.1.0

Level 2 is renamed from "vending machine" to "soda pop". The storage identifier behind it is deliberately NOT renamed in implementations that already persist a reader's choice: renaming it would silently reset every saved level. The name is what the reader sees; the identifier is not.
Two reserved expert levels are added above black coffee, loose leaf and yerba mate. They are reserved names and glyphs, not reading levels, and they carry no step number. The standard remains thirteen steps.
Each of the four passes now names its icon by Unicode codepoint, so the icons are normative while this document stays ASCII.
The opening line is clarified: thirteen steps every time does not mean thirteen units of work every time. It already said so further down, and now it says so where a reader meets it.
The command template library section no longer names private repositories, an internal collection path or an internal publish page. The normative content, the field list and the one-canonical-copy requirement, is kept.