An open, machine-readable controlled language for specifications that humans and AI agents both have to execute.
Klaar is Dutch for two things at once: clear, and ready. A specification that is not the first cannot be the second.
Built by Studio Groei, a venture studio that runs an autonomous delivery loop. We wrote this because our own agents kept building the wrong thing from specifications that read fine to a human.
Ambiguity in a specification does not make a coding model fail loudly. It makes it fail quietly. Measured on GPT-4, the rate of generated code that runs but is wrong climbs from 24% on a clean task description to 65% on an ambiguous one and 89% on a contradictory one (arXiv:2507.20439). A second, independent benchmark puts the pass@1 drop at roughly 28 percentage points (arXiv:2604.21505).
The obvious fix, "the agent will ask when something is unclear", does not work. Models locate the source of an ambiguity in fewer than 23% of cases, resolve it in under 60%, and in more than 63% of ambiguous scenarios they never ask at all. They pick an interpretation and proceed.
So the gate has to sit before the agent, not after it. That is what KLAAR is.
Simplified Technical English is the standard everyone points at, and it works. It is also:
| ASD-STE100 | KLAAR | |
|---|---|---|
| Distribution | PDF only, behind a request form | JSON is normative; prose is generated from it |
| Licence | Free to download, but reproduction "in whole or in part" needs written permission; the exemptions cover aerospace, defence and universities | CC BY 4.0 (spec) · CC0 (rules and lexicons) · Apache-2.0 (tooling). Fork it, embed it, redistribute it |
| Language | American English only | Language-independent core plus profiles. Dutch and English in v0.1 |
| Conformance | "ASD and the STEMG do not endorse or certify any company" — so "compliant" means nothing | A conformance suite ships with the standard. You demonstrate conformance; nobody grants it |
| Release cadence | Roughly every three years | The rules are data, released like software |
There is no open alternative today. We checked: the five GitHub projects that mention STE have about fifteen stars between them, none carries a licence, and none contains a vocabulary. Vale's official package registry, which serves documentation teams at Google, Microsoft, IBM and Red Hat, contains no controlled-vocabulary style at all. Meanwhile commercial checkers start at €35 per writer per month.
KLAAR is a clean-room design, not a copy. It solves the same problem with a different scope, a different structure and its own rules. See CLEANROOM.md.
Machine-readable first. Every rule is a JSON record with a stable id, an executable definition and its own test fixtures. The prose specification is rendered from the data. A tool written in any language can read the same pack and reach the same verdict.
Bilingual by design. The core rules are language-independent. Everything that depends on a language lives in a profile. Dutch needs six rules English does not have, including compounds that must be closed up (invisible to every spell checker, because both halves are real words) and the tangconstructie, which predicts comprehension better than sentence length does. That layer has never existed for Dutch.
Every rule states its evidence. This is the part no other writing standard does.
| Class | Meaning |
|---|---|
measured |
Published empirical evidence that violating this degrades outcomes |
plausible |
Argued in the literature, not causally demonstrated |
convention |
We chose it for consistency. No evidence is claimed |
Requirements-quality research "mostly fails to connect requirements quality to its impact on subsequent software development activities" (arXiv:2309.10355). There is even counter-evidence: removing constraints sometimes improves correctness, because specific constraint wording can prime a model toward the wrong input handling (arXiv:2604.24712). Pretending otherwise would make this a style guide with footnotes. Read spec/04-bewijs.md before you adopt anything here.
Levels, not all-or-nothing. Attempto Controlled English is the most rigorous controlled language ever built and almost nobody uses it: a sentence was either ACE or it was not. KLAAR has three levels, and level 1 needs no linguistic parsing at all.
The standard and the linter ship together. Caterpillar's Fundamental English was abandoned in 1982, in part because its guidelines "were not enforceable in the English documents produced". A rule nobody can check is a preference.
npm install -g klaar # or: npx klaar lint docs/Node 18 or newer. No dependencies.
klaar lint offerte.md --level 2
klaar lint docs/ --format sarif --out klaar.sarif # inline annotations in a PR
klaar check # validate the rule pack itself
klaar conformance # run every rule against its own examples
klaar rules --evidence measured # which rules rest on research
klaar export-vale --lang nl # if you already run Vale
klaar prompt --lang nl # the writing instruction, for a person or an agentAs a library:
import { loadPack, lintDocument } from 'klaar';
const pack = loadPack();
const result = lintDocument(markdown, { file: 'offerte.md', level: 2, pack });
const blocking = result.findings.filter((f) => f.severity === 'error');klaar prompt renders a short writing instruction from the rules themselves, ready to
append to a system prompt or drop into an agent's instruction file:
klaar prompt --lang nl --level 1 --out .claude/KLAAR.mdThe generated text is also shipped, at prompt/klaar-prompt.nl.md
and prompt/klaar-prompt.en.md.
Two things about it are deliberate, and both cost something.
It renders only what is enforced for the level and artefact kinds you ask for. Teaching a
sentence shape that the linter will not check on that kind of text would leave the reader
unable to tell which half of the instruction is binding — and a rule nobody can check is a
preference. If a shape ought to apply somewhere, widen the rule's scope, not the prompt.
It teaches the form, not the list. The forbidden-word lexicons hold seventy terms; the instruction shows a category and about seven examples. A model does not need the list, because the linter names the exact word when it fires. Every word spent on the instruction is a word not spent on the task it is attached to, and there is published evidence that removing constraints can raise correctness rather than lower it. The shipped instruction is budgeted at 300 words and CI fails if it grows past that.
CI also fails if a rule changes and the shipped instruction is not regenerated. That is the entire reason it is generated rather than written by hand.
| Level | Name | What it adds | Cost to adopt |
|---|---|---|---|
| 1 | Kern / Core | Normative keywords, forbidden hedges, quantification, one obligation per statement, explicit actor, resolvable references | Turn it on today. Deterministic, no parsing |
| 2 | Streng / Strict | Language-profile rules, the six requirement shapes, boundary inclusivity, evidence per requirement | A rewrite pass over your templates |
| 3 | Gesloten / Closed | A closed approved vocabulary | Not released in v0.1. See spec/00-conformiteit.md |
A requirement is written in one of six shapes, or it is explicitly marked VRIJE-VORM
with a reason.
| Shape | Dutch | English |
|---|---|---|
ALTIJD |
<systeem> MOET <respons>. |
The <system> MUST <response>. |
ZOLANG |
ZOLANG <toestand>, MOET <systeem> <respons>. |
WHILE <state>, the <system> MUST <response>. |
WANNEER |
WANNEER <trigger>, MOET <systeem> <respons>. |
WHEN <trigger>, the <system> MUST <response>. |
ALS |
ALS <trigger>, DAN MOET <systeem> <respons>. |
IF <trigger>, THEN the <system> MUST <response>. |
INDIEN-AANWEZIG |
INDIEN <functie> aanwezig is, MOET <systeem> <respons>. |
WHERE <feature>, the <system> MUST <response>. |
KAN |
<rol> kan <handeling> via <oppervlak>, met <resultaat>. |
The <role> can <action> via <surface>, with <result>. |
The escape hatch is not an admission of defeat. A controlled language covers 88% to 94% of
real industrial requirements (arXiv:2005.01355).
Claiming 100% would push people to smuggle prose into the template, which destroys exactly
the parseability that was the point. The share of VRIJE-VORM blocks is a quality metric
of the standard, not of the writer.
spec/ the human-readable specification (CC BY 4.0)
rules/ one JSON file per rule; this is normative (CC0)
schema/ the JSON Schema every rule validates against
lexicon/ word lists, with the provenance of every single term (CC0)
tools/klaar/ reference linter, conformance runner, Vale exporter (Apache-2.0)
conformance/ fixtures beyond the per-rule examples
examples/ real documents, before and after
A change proposal names the rule, the change, the goal, and evidence from real
documentation. New rules must carry an honest evidence class; convention is a
perfectly good answer and is preferred over an inflated claim.
Every contributor confirms the clean-room declaration in CLEANROOM.md.
| Part | Licence | Why |
|---|---|---|
spec/, docs |
CC BY 4.0 | Attribution builds the standard's name; no share-alike, so vendors dare to embed it |
rules/, lexicon/ |
CC0 1.0 | Tool builders must be able to embed the data with no attribution burden per copy |
tools/ |
Apache-2.0 | Explicit patent grant, and section 6 deliberately grants no trademark rights |
v0.1 — early. The rules are written, the linter runs, and every rule passes its own fixtures. What is not done yet: level 3, a measured precision figure for each heuristic rule, and an independent legal review of CLEANROOM.md. Those are named in the issues rather than glossed over here.
KLAAR is not affiliated with, endorsed by, or certified by any other standards organisation. References to other standards are nominative, to describe what this one is not. See TRADEMARK.md.