Answers served by Konneal

Skip to content

Techniques

This page documents the techniques used across the system. Each entry describes a mechanism, explains how it works, and states which problem it solves.

The staircase of representations

The techniques on this page operate on a progression of corpus representations, which runs from plain text through clause-anchored documents and typed table, formula and figure units, to machine-readable models of the Recommendations that the system can execute rather than quote.

The techniques on this page either add structure to the corpus, retrieve over that structure, verify answers against it, or execute it. The value of structure was measured directly: six representations of the same corpus were indexed and graded on 18 capability probes. Plain text answered 2 of the probes, and the full serving stack answered 17 to 18. Representation quality and serving techniques multiply rather than add.

Try the retrieval yourself

The mechanism this page describes is the one that answers on the front page. Describe a problem in your own words — the phrasing a person uses, not the phrasing a standard uses — and the search returns the passages the corpus offers, with the publications and clauses they come from.

The search runs against the live service and shares the anonymous daily allowance with the chat. Nothing is stored.

Corpus construction

These techniques prepare the corpus before any question is asked. They determine how much structure the retrieval system and the answer contract can rely on.

Clause-boundary chunking

The system splits each document along its own clause structure, which is the structure the authors wrote, instead of cutting it into fixed-length token windows. Every chunk carries the number of the clause it came from, so a citation can name an exact location in the source document.

Without this technique: Text that is split by token count carries no clause references, so the system cannot tell the user where an answer comes from.

Contextual enrichment

At index time, a language model writes a short preamble for every chunk that states which publication, part and clause the chunk belongs to and what the clause covers. The index stores the preamble together with the chunk text. Because this pass runs once over the whole corpus, its quality carries into every future retrieval without recurring cost. The preamble generator runs at the highest reasoning effort, a choice that a blind judged comparison settled: high effort won 58 percent of judged pairs against 25 percent for low effort, at equal preamble length.

Without this technique: A chunk without situating information is ranked only by the words it happens to contain, and queries that name a publication identifier often fail to find the right passages.

Typed units

Tables, formulas and figures are extracted from the source documents as structured objects rather than as prose. A formula keeps its original notation and is rendered as mathematics (converted with Plurimath); a table keeps its columns and rows as data; a figure keeps its original drawing as an image that the answer model can inspect.

Without this technique: When tables and equations are flattened into running text, the system cannot show the actual object, and answers disclaim information that the document plainly contains.

Terminology graph

The corpus defines its own technical vocabulary. The system links each defined term to the clause that defines it, across roughly nine thousand concepts drawn from the metrology vocabulary (VIM and VIML) and the corpus glossaries.

Without this technique: Without the linkage, the system has no way to connect the words a user writes to the defined terms that the corpus actually uses.

Bibliographic registry

A registry of 5,707 bibliographic records organizes the publications into 224 families and records each family's editions and supersession links. The system derives which edition is current from the record's own supersession links instead of trusting a status field, because the status field disagrees with the links in 58 known cases.

Without this technique: Questions about which edition applies are answered by guesswork, and superseded editions are cited as if they were current.

Machine-readable models

For the Recommendations that carry machine-readable models, the system indexes the model itself: typed attributes, constraints with numeric limits, calculations and test sequences. These models are the basis for conformance checking by execution, which is described below.

Without this technique: A rule that exists only as prose can be quoted, but it cannot be evaluated against the values a user provides.

Retrieval

These techniques determine which passages the system finds for a question.

Query understanding

Before retrieval begins, a small language model reads the question and determines its language, any publication or edition it names, the user's intent, and a standalone reformulation when the question is a follow-up. The same model makes these judgements for every question in every language, and no keyword rules are involved.

Without this technique: Keyword-based routing behaves differently depending on how a question is phrased, so equivalent questions receive different treatment.

Hybrid retrieval

The system searches the corpus in parallel with a vector similarity search and a full-corpus lexical scan, then merges the results with reciprocal rank fusion. It also runs several rephrasings of the question as separate search lanes and uses a hypothetical draft answer as one additional search key.

Without this technique: A vector search alone misses exact technical identifiers, and a lexical search alone misses paraphrase; each fails on questions that the other answers.

Structural retrieval over the clause tree

The corpus is organized as a tree of clauses. When the system scores a candidate passage, it also considers the scores of the passage's parent and child clauses, so a section whose clauses are collectively relevant rises in the ranking. The evidence is presented to the answer model in document reading order, and near-duplicate passages from the same clause chain are collapsed.

Without this technique: Retrieval over flat chunks has no notion of the section that surrounds a clause, and duplicated passages consume the context window without adding information.

Section-summary units

For every top-level clause, the system builds a retrievable summary. When a summary matches a question, retrieval descends to the quotable child clauses underneath it, and the summary itself is not cited. Citations therefore always quote source text.

Without this technique: An index with a single granularity is either too coarse to cite accurately or too fine to give the model an overview of a section.

Vocabulary binding

Users describe symptoms in everyday words, while the corpus expresses the same concepts in defined terms. The terminology index links the user's phrasing to candidate defined terms, and the answer presents the corpus's own term together with its definition and the clause that defines it.

Without this technique: The system fails on the step from everyday language to defined terminology, which measurement shows is a vocabulary problem that no corpus representation solves on its own.

Reranking, edition steering and typed pinning

A cross-encoder reranker orders the candidate passages by relevance. Edition steering demotes superseded editions within a family while keeping them citable when only they contain the required content. When the question names a specific document, retrieval is scoped to that document deterministically, based on the question text rather than on a model decision. Typed objects such as tables and figures are pinned to a reserved slot in the evidence so that the answer can reference them, and a question that names an artifact type determines which object is pinned.

Without this technique: Ranking by similarity alone retrieves passages from superseded editions, guesses at document scope, and rarely surfaces the table or figure that the question is actually about.

Standard-reference boosting

Many clauses cite external standards such as ISO/IEC 17025 by identifier. When a question names that standard, passages that cite it are boosted in the ranking, so the citation itself acts as a retrieval signal.

Without this technique: The clause that cites the standard directly loses to passages that merely mention the topic in general terms.

Citation graph traversal

A citation graph records which standards each publication cites, extracted from the bibliographies of the indexed editions and stored as graph edges beside the publication registry. When a question asks what a publication cites or references, the answer draws the cited-standards list from the graph as authoritative structured data, while the bibliography passages themselves are retrieved to ground the answer verbatim. Structured questions get graph answers, semantic questions get vector answers, and the two are fused when a question needs both.

Without this technique: The bibliography section must first be found by text similarity, which rarely matches the question's phrasing, and the answer model then re-extracts the citation list from prose on every answer.

Edition cover

When the candidate pool for a publication family contains only superseded editions, the system consults the registry for the active edition and retrieves from it directly. The answer then cites the current rule even when the first retrieval pass missed it.

Without this technique: The system returns an answer that is correct for a superseded edition and therefore outdated.

Answer integrity

These techniques keep the generated answer verifiable against the corpus.

The answer contract

Every substantive claim in an answer must carry an inline citation, and any normative value must be quoted verbatim from the cited passage. A deterministic check runs after generation: each quoted span must appear in one of the served passages, and any table that is shown must carry its object reference. When the check fails, generation is retried once with a correction note.

Without this technique: Generated prose cannot be checked mechanically, so errors in values and attributions go undetected.

Typed-object rendering

Tables, formulas and figures are rendered from the structured source objects. Formulas are rendered as mathematics from their source notation, tables are rendered from their rows and columns as data, and figures are shown from their original drawings. The answer model never retypes these objects.

Without this technique: A model that retypes a table introduces transcription errors that carry the authority of a citation.

Schema-aware table context

When a table is part of the evidence, the system selects the columns and rows whose contents overlap the question terms and composes only those into the model's context. The full table remains available for rendering. This approach follows the cell-selection strategy introduced for table question answering.

Without this technique: Whole tables consume the context window as they grow, and the precision of table answers falls accordingly.

In-context reading of the original

Every rendered publication is stored at a permanent address together with a map from each clause number to its position in the rendering. A citation in an answer therefore opens the original document at the exact cited clause, either in a side panel beside the conversation or in a new tab. The rendering is produced from the same source that the index was built from.

Without this technique: A citation names a location that the reader cannot visit, so verification depends on trust in the extraction rather than on the document itself.

Multimodal figure interpretation

When a question concerns a drawing, the system attaches the figure's image to the generation call so that the model interprets the drawing itself rather than its stored caption. The image is attached only when the question asks about a figure, and it is sent as its own message because the model provider rejects requests that combine long text and image parts in one message. If the multimodal call fails, the image is removed before the fallback call.

Without this technique: The system answers from the caption alone and disclaims details that are plainly visible in the drawing.

Citations that open the original document

Every publication in the curated corpus is rendered to a self-contained page that carries the corpus's own clause anchors. A citation's clause becomes a link that opens the original document at the cited clause, with the clause highlighted and its neighbouring clauses visible, inside the answer. The reader verifies a quote against the document itself rather than against a stored snippet.

Without this technique: The reader receives a snippet beside a link to a file and must find the cited passage by hand.

Beyond retrieval

These techniques execute the corpus instead of searching it. They apply to publications that carry machine-readable models.

Conformance checking by execution

When a question names a rule that has a machine-checkable model, the system evaluates the rule instead of quoting it. The values in the question are bound to the rule's parameters, a deterministic evaluator runs the check, and the verdict is attached to the answer as data. The verdict reports pass, or the standard's own word for the violation, or void when parameters are missing. Hypothetical values are evaluated the same way as real ones.

Without this technique: The system quotes the rule and leaves the arithmetic to the reader, which is where errors enter in manual practice.

Severity membership by execution

The test-method packages (the IEC 60068 and 61000 families the Recommendations cite for their test procedures) encode their severity menus as condition sets: typed quantity values with a value, a unit and a tolerance, provenance-linked to the standard’s own table. When a question states quantities and asks about a severity, the service checks the stated values against every set’s bands: an admitted combination passes and names its set; a combination no set admits fails and names the nearest set with the violated bands. The evaluation runs server-side and the result is attached as data, grounded in the 2024–2026 tool-execution literature (PAL, Program of Thoughts, TableRAG).

Without this technique: The severity menu is quoted from prose, and the reader must check the bands by hand against whichever table the model happened to retrieve.

Provable absence

When a user asks whether a standard constrains something, the system can enumerate the standard's entire model and return a certificate of absence that states how many nodes were enumerated, that none of them matched, and what scope the enumeration covered.

Without this technique: A plain refusal states that the system found nothing, which is not evidence that nothing is there.

Answer verification

Any answer, whether produced by this service or by another system, can be checked against the corpus. The deterministic checks verify that each quoted span appears in a retrieved passage and that every referenced object resolves to a served object. A judged faithfulness score is reported separately and is labeled as judged rather than mechanical.

Without this technique: The correctness of an answer is a matter of trust rather than measurement.

Research mode

Research mode runs a bounded loop of at most three passes. In each pass the system retrieves evidence, and an independent judge then evaluates whether the evidence is sufficient to answer and names what is missing; the next pass retrieves specifically for the missing parts. The final answer is generated from the accumulated evidence. The feature is available to signed-in members.

Without this technique: A single retrieval pass answers from whatever it happens to find and has no way to notice its own gaps.

Trust, measurement and economy

These techniques keep the system honest over time and keep its operating cost under control.

Measurement gates

A golden set of 38 questions with expected citations and witnesses runs three times against the live service before any change is promoted, together with a capability battery of 18 questions. Grading is deterministic wherever possible: expected spans must appear in retrieved passages. Judged components are labeled as judged. Gates are never run while the index is being modified, because an honest measurement requires a settled system.

Without this technique: Single-run evaluations pass on luck, and changes ship regressions that no one notices until users report them.

Personalized memory and projects

Signed-in members can attach bounded memory files to their account, and a group of conversations can share one project memory. The selected memory participates in a question the same way a selected database does. Whatever context is selected is included in the answer cache key, so two members with different memories can never be served each other's cached answer.

Without this technique: Personalization without a cache key shares one member's context with the next, which is both wrong and a privacy defect.

Dataset scope with permission gating

Users can select which databases a question draws from: OIML Publications, OIML SMART Models, or ISO/IEC Conformity Assessment. The server intersects the selection with what the session is authorized to see. The ISO/IEC corpus requires an estate permission that is managed in the identity service, and membership alone does not grant it.

Without this technique: A single monolithic corpus cannot be narrowed to the user's intent, and access control that depends on login alone exposes restricted content to every member.

Structural index isolation

Public OIML content and internal, access-restricted content are stored in physically separate vector indexes and storage buckets. The public worker holds no binding, token or route that can reach the internal index.

Without this technique: Isolation that depends on a filter is one forgotten condition away from leaking restricted content into public answers.

Indexing under a declared contract

Every chunk that enters an index passes through a single validated boundary that enforces the declared data contract, the legal metadata shapes and the target index's allowed corpora. The set of chunk files that serve production is declared in one place, and reconciliation deletes only what that declaration does not contain. Contextual enrichment is replayable from a durable record after any index rebuild.

Without this technique: Index contents drift away from the build artifacts, rebuilds silently lose enrichment, and malformed payloads are rejected wholesale with opaque errors.

Generation-stamped answer caches

The answer caches carry the generation of the corpus they were computed against. After any change to the index, answers from the previous generation stop being served and expire within minutes.

Without this technique: Cached answers continue to describe a corpus that no longer exists, with full confidence.

Configurable answer depth

Answers are produced at two depths. Fast, the default, uses the standard reasoning effort. Thorough raises the reasoning effort and doubles the output budget so that the additional reasoning does not consume the answer. The depth is a per-request choice for signed-in members, and a Thorough answer consumes two units of the daily quota.

Without this technique: A single fixed depth is either needlessly slow for simple questions or too shallow for demanding ones, and raising the effort without raising the output budget starves the answer: on the golden set, raised effort with the original budget passed 5 of 38 cases, while the same effort with the coupled budget passed 36 to 38 of 38 across three consecutive runs.

Grounded in the literature

The execution and retrieval techniques on this page adopt, in this deployment’s context, results from the 2024–2026 literature. The full mapping — technique, source, where it lives in the system, and how the adoption differs from the paper — is in the research notes.

  • Computation offload. Program-aided language models (PAL, arXiv:2211.10435) and Program of Thoughts (arXiv:2211.12588) remove numeric hallucination by letting a deterministic runtime compute while the model reasons. This deployment adopts the pattern without the program generation: the standard’s own machine-readable rule is the program, the question supplies the values, and the engine executes. The answer model narrates the computed verdict and never recomputes it.
  • Step-level evidence. The process-supervision line (OpenAI, 2023, and the 2024–2025 reward-model work) shows intermediate steps are what make numeric output trustworthy. Verdict blocks here render one row per machine check — the expression, the bound values, the individual result — so the reader audits the arithmetic instead of trusting a summary.
  • Structured numeric retrieval. TableRAG (arXiv:2410.04739, NeurIPS 2024; arXiv:2506.10380, 2025) shows dense retrieval misses exact numeric matches and that aggregation belongs to a deterministic executor. The severity menus of the test-method packages are encoded as typed condition sets and evaluated by membership: a stated combination is checked against each set’s value-plus-tolerance bands, the matching set is named, and an out-of-band combination fails naming the nearest set.
  • Hybrid retrieval. Dense-plus-lexical consensus (arXiv, July 2025) and HyDE (arXiv:2212.10496) ground the parallel-lane design: a vector search, a full-corpus lexical scan, several rephrasings and a hypothetical draft answer run concurrently, fused by reciprocal rank, with self-query metadata filters (edition, document number, status) on top.

The deployment deliberately does not adopt in-context SQL engines (the typed payloads and their evaluators cover aggregation without a query engine in the loop) or self-consistency sampling on the serving path (latency). The research notes also carry the prioritized improvement list the literature suggests next, led by deterministic aggregation over table payloads and selective cell retrieval.

A narrative description of the system is available on How it works. The measurement methodology is described on Knowledge annealment, and the academic treatment is available in the whitepaper.