Six capabilities. One thing that a professional will sign.
The knowledge base is the floor — not the product. The KnowledgeEngine is the system built on top of it: six reusable capabilities that turn a governed corpus into a verdict with evidence, confidence, and an audit trail.
A knowledge base is where most “document AI” stops.
Index a corpus, bolt on a chatbot, add citations: you have a product that sounds right. For work that can be wrong with consequences — a LEED submittal, a supplier ESG audit, an IEP compliance review — that's not enough. The KnowledgeEngine is what turns the floor into a verdict you can defend.
Grounded
Every output is anchored in the knowledge base and traces to the exact rule it rests on. The engine cannot invent a regulation it isn't holding.
Defensible
Verdict, evidence, and confidence on every requirement; deterministic math; an expert override that recalculates; a full audit trail. Built to show its work.
Correctable
Every value is overridable and the override propagates. The output is not a black box — it's a structured document an expert can interrogate and correct.
Why grounding matters
A knowledge base isn't a pile of documents in a chatbot.
The most common question we get: “can't I just upload our documents to an LLM?” You can — and for regulated work, that's exactly where it breaks. Here's the difference.
A pile of documents in an LLM
- ✕Everything weighs the same. A forum post and a federal regulation are retrieved as equals — the model can't tell authority from anecdote.
- ✕Frozen at upload. It knows whatever you pasted, whenever you pasted it. Codes change; the pile doesn't.
- ✕No version or jurisdiction sense. v4 vs v4.1, your state vs another — it can't keep them straight.
- ✕Retrieval by vibes. Similarity search grabs passages that sound related, then the model fills the gaps — confidently.
- ✕No precedence when sources conflict. When two documents disagree, nothing decides which one wins.
A governed knowledge base
- ✓Ranked by authority. Law outranks standard outranks policy outranks anecdote — every time.
- ✓Version & jurisdiction aware. The engine knows which edition and which region governs this case.
- ✓Cited to the source. Every claim traces back to the exact rule it rests on — checkable, auditable.
- ✓Current & maintained. As regulations change, the knowledge base updates — not a frozen snapshot.
- ✓Conflicts resolved by precedence. When sources disagree, the hierarchy decides which one controls.
A pile of documents can tell you what a paragraph says. A governed knowledge base can tell you what actually governs your decision — and prove it.
How the engine works
From your documents to something you can act on.
One pipeline, every product. Ground it in what's true, read the hard documents, and turn the evidence into the tool the job actually needs.
Knowledge base
Everything the engine is allowed to treat as true — your world, plus the rules that govern it.
Document & complex-data extraction
The engine reads the artifacts your experts read — and turns them into structured, scored evidence.
- Ingest complex docs, drawings, models & data
- Structured evidence with confidence
- Score every requirement against the framework
- Deterministic checks where the numbers matter
From floor to output. What each layer does.
Each capability builds on the one below it. Together they produce a structured output an expert will put their name on.
Knowledge base
The floor — not the ceiling
Every other capability rests on this. The knowledge base is not a pile of documents in a chatbot — it's a governed corpus, ranked by authority, version-aware, and jurisdiction-scoped. Laws outrank standards; standards outrank policy; policy outranks anecdote — every time.
Multi-model orchestration
~60 agents, dependency-gated
No single model does this work well. The engine deploys a coordinated set of specialized agents — some for extraction, some for scoring, some for deterministic verification — gated by dependency so each step waits for the evidence it needs. Model-agnostic: Claude, GPT, Gemini, or open-source; swapped as better ones ship.
Structured scoring
Every requirement. Evidence and confidence.
Every framework requirement is scored against the evidence in the knowledge base — not summarized, not paraphrased. Each score carries the evidence that supports it and a confidence level that flags uncertainty rather than hiding it. A professional can check every call.
Deterministic QA
BEM-QA — the numbers are code, not guesses
Where the job involves math — energy model arithmetic, submittal calculations, regulatory thresholds — the engine runs deterministic code, not a language model guess. BEM-QA validates building energy models against the engineering rules they're supposed to satisfy, producing an auditable calculation trail.
Expert overrides
Human-in-the-loop with recalculation
The engine is designed to be corrected. Every scored value is expert-overridable — and an override propagates. Change one input and the dependency graph recalculates; the whole analysis stays consistent. This is what makes the output something a professional will sign: it's correctable in the way their own work is.
Living Canvas + advisor
Plain-language explanation, voice interface
A verdict without explanation isn't useful to a practitioner who needs to act on it. Living Canvas is the advisor layer: a grounded conversational interface that explains the output in plain language, answers follow-up questions against the same evidence base, and is available by voice. It can't make things up — it's bounded to what the knowledge base holds.
One consistent output. Correctable at every level.
The engine doesn't guess. It scores.
Each requirement in the framework gets a verdict — pass, fail, or flagged — against the evidence in the knowledge base. The evidence is cited. The confidence is explicit. If something is uncertain, it says so rather than smoothing it over.
The numbers are code, not LLM output.
Where the job involves arithmetic — energy model calculations, threshold checks, submittal quantities — the engine runs deterministic code. The math is auditable. Anyone can check it.
Expert corrections propagate.
When a practitioner overrides a value — because they know something the engine doesn't — that correction flows through the dependency graph. Related scores recalculate. The whole analysis stays consistent, not frozen at the moment of import.
The advisor is bounded to the evidence.
Living Canvas, the conversational layer, explains the output in plain language and answers follow-up questions — but it is bounded to what the knowledge base holds. It can't generate a citation it isn't holding. That's the difference between an advisor that helps and one that misleads.
LEEDSmart is all six capabilities, running live.
Green-building submittals in. Credit-by-credit verdicts — with evidence and confidence — out. The energy model QA'd deterministically. Expert overrides that propagate. An advisor that explains the whole thing in plain language. Every one of the six capabilities, pointed at the LEED framework, in production.
Tell us the documents and the rules.
We'll build the engine around them.
A pilot proves a single framework fast — the shortest path from “could AI do this?” to a verdict your experts will sign.