01 · The short answer: grounded generation with a paper trail, and people at every gate
When your team uploads source material (policies, curricula, product documentation), it doesn't disappear into a black box. Each document is parsed, split into passages, indexed, and becomes part of a project knowledge base your authors control document-by-document. When AI generates content from it, the relevant passages are retrieved and placed in front of the model labeled with the file they came from, and the finished piece carries a provenance record: which documents, which specific passages, which conversation, which AI model, and when. For grounded content, the system won't even run the generator if no source materials exist — it asks for them instead of improvising.
Generation itself isn't one big model doing everything. It's a team of narrow specialist agents: an interviewer that draws knowledge out of your subject-matter experts, and designers for learning briefs, objectives, scenario decisions, scoring, and characters — each running at a "temperature" (creativity level) deliberately set for its job: near-zero for precision work, warmer for creative work.
Everything they propose passes automated validation and certification and is measured against benchmark suites, and the author is in the loop the entire time, not just at the end: progress streams live into their workspace, plans pause for their approval, and publishing is a deliberate human decision backed by automated certification. And what your learners ultimately experience — scores and simulation outcomes — is executed by deterministic engines with no AI in them at all.
02 · The content pipeline: the life of your content, end to end
Source materials come in (ingestion). Your team uploads documents: PDF, Word, Excel, web pages and more. Each is parsed into text, split into passages, and converted into a searchable index (embeddings in a knowledge store), with progress visible as it processes. Every passage keeps its origin: which file, which location.
Authors control the source set (human control). Uploaded documents appear in a Sources panel. Authors toggle each document on or off at any time, deciding exactly which materials the AI is allowed to draw on. Knowledge can also be captured live: an SME-interviewer agent conducts a structured interview with your subject-matter expert, one focused question at a time.
Grounded generation (AI · retrieval). The system retrieves the relevant passages and hands them to the generator with each passage explicitly labeled ("Source: filename"), and the agent instructed to cite sources by identifier. If a project has no source materials, grounded generators refuse to run and tell the author what's missing rather than inventing a substitute.
The specialist agent team does the drafting (AI · multi-agent). A router decides what kind of request this is; a planner breaks it into small, independent steps (and pauses for your approval when a plan is multi-step or would remove existing work); then specialists draft — learning briefs, objectives, content maps, scenario phases, decisions, scoring rules, characters, coach and teacher behavior. Between every AI step sits a deterministic gate: the next step only runs if the previous one produced valid output.
Validation and certification (automatic). Every operation an agent proposes is checked against reality before it lands (real fields, approved design values, safe structure) and rejected with a precise, correctable explanation when wrong. Finished components must pass a 17-point certification covering structure, on-brand styling, interactions, accessibility, and localization readiness. Simulation scoring models are separately validated for structural soundness (weights, cycles, orphaned rules).
Human review and sign-off (human gate). The author reviews everything in place, with the provenance record showing which sources fed each generated document, and chat links that open the exact source document. Publishing itself is a human act: the author inspects the result and chooses to publish, and certification failures block it. Every AI action is undoable and captured in an append-only audit journal.
Learners run on deterministic engines (no AI). Published simulations and assessments execute on engines with no AI in them. Scoring is authored, validated data; the same learner choices always produce the same result. Published packages are fingerprinted so what you approved is exactly what runs, and in-progress learners are pinned to the version they started on, for as long as that version remains available.
03 · The agents: 24 specialists, not one general-purpose model
That's the current count of distinct, named AI agents behind the platform — each a separately defined role with its own instructions and model assignment, and in nearly every case, a creativity setting calibrated to the role. Narrow mandates are a quality control in themselves: an agent that only routes, or only fills in a form to match a schema, has far less room to improvise than a general assistant.
Routing & planning
Decide what kind of request this is and break it into small, checkable steps before anything is generated: the Router (answer, delegate, or clarify), the Authoring Planner (decomposes requests, max 8 steps), the Operation Router & Shaper (picks one tool, fills it to schema), and Modification Classifiers (interpret edit requests).
Knowledge & source intake
Get your expertise and materials into the system faithfully: the SME Interviewer (structured expert interviews), the Course Extractor (structures existing course content), and the Summarizer (concise, faithful digests).
Learning design
Draft the instructional backbone from your sources, with quality rubrics built into their instructions: the Learning Brief Designer, Learning Objectives Designer (measurable objectives), Content Mapper, Topic Summarizer, and Artifact Generator (instructed to cite sources by id).
Simulation design team
Six coordinated roles assemble a simulation scaffold, after a human fills in the vision (topic, objectives, duration): the Cast Designer (characters), Phase Designer (narrative arc), Decision Designer (no single "right" answer), Scoring Designer (weights must sum to exactly 1.0), Teacher Designer (Socratic knowledge), and Coach Designer (intervention triggers).
Building & styling
Turn approved designs into working pages and components, forbidden from inventing component types or off-brand values: the Builder Agent (pages & layout), Component Builder (reusable component types), Page Generator, and Character Author (the most creative role).
Review & guardrails
Review is deliberately not another creative AI's opinion. Quality gates are deterministic (schema validation, certification, benchmark suites) because rules don't hallucinate. AI reviewers exist (a visual-design judge, a test-run evaluator) but are advisory only: they inform humans, they never decide. The final reviewer is always a person.
04 · Provenance & traceability: every piece can answer "where did this come from?"
The provenance record
Each AI-generated document carries a structured record created at generation time:
which source documents were used, and which specific passages from each
which conversation and messages requested it
which concepts from the project's knowledge model it drew on
which AI model and instruction set produced it, and when
Authors verify sources before publishing, and you can audit any piece after the fact.
Traceability in the authoring experience
Source references in the AI's replies are clickable, and they open the exact document in the workspace. In today's platform, source passages carry file name and page number, answers from the document service return the exact supporting passages with relevance scores, and answers can be highlighted directly in the source PDF. Grounded answers are explicitly split: what comes from your documents versus what comes from general knowledge — and "not enough context provided" is a sanctioned answer. "Show me where that came from" has a literal answer.
Refuse rather than imagine
Grounded generators check for source material before calling the model. No sources uploaded? The system tells the author exactly that and stops. The same posture runs through the platform: the builder agent is instructed never to invent component types; tool schemas validate every value against what actually exists; and structured operations that reference something imaginary are rejected with a correction. The default on missing information is "ask," not "improvise."
The audit trail
Beyond content provenance, every operation an agent performs is recorded in an append-only journal, every agent edit is undoable, and published packages are content-fingerprinted: the bytes you approved are provably the bytes that run. Three layers of accountability: what was used, what was done, what shipped.
05 · Document architecture: how documents are processed, and how knowledge comes back out
Two halves of one system: an ingestion pipeline that turns your documents into an indexed, source-tracked knowledge base, and a retrieval loop that pulls the right passages back out, labeled, whenever content is generated from them.
Ingestion: getting documents in
Upload. Your team adds source materials (PDF, Word, PowerPoint, Excel, web pages and more) to the project.
Secure storage. Files are validated and stored; each becomes a tracked source document in the project workspace.
Parse & extract. A document-understanding engine extracts the text and structure from each format.
Split into passages. Content is divided into retrievable passages. Every passage keeps its origin: which file, which location.
Index for meaning. Each passage is converted into a semantic representation (embeddings) and stored in the project's knowledge index — searchable by meaning, not just keywords.
Processing progress streams live to the author's workspace, stage by stage (extracting, indexing, done), so the state of every document is always visible.
Retrieval: getting knowledge out
Author curates the source set. In the Sources panel, the author switches each document on or off at any time. Only enabled sources are in play.
A request is made. "Draft the learning brief from our compliance policy." The request travels with the enabled source list.
Relevant passages are retrieved. Not a single search, but a multi-strategy retrieval stack: query understanding, parallel search methods, rank fusion, and neural re-ranking (detailed below).
Generation, with labeled evidence. Retrieved passages enter the agent's briefing each tagged "Source: filename," with instructions to cite. No sources for a grounded request? Generation refuses and asks.
Output + provenance record. The result is stored with its provenance: which documents, which passages, which conversation, which model, when.
Verify & trace. Clickable references open the exact source document; in today's platform, answers highlight back to the page in the source PDF, with relevance scores.
The same index also powers document Q&A: ask a question, get an answer with the exact supporting passages attached — with "not enough context in your documents" as an honest possible answer.
Inside the retrieval step: the search stack
"Find the relevant passages" sounds simple; doing it reliably on messy, real-world corporate content is not. The document-intelligence pipeline treats retrieval as a discipline of its own, using the same techniques you'd find in state-of-the-art search systems:
Query understanding. An AI classifier first works out what kind of question this is (about a specific document, an entity, a relationship, the whole corpus) and adapts the strategy: which search methods to run, which filters to apply.
Multi-query expansion. The request is expanded into several alternative phrasings, each searched in parallel, so one choice of words doesn't cause relevant material to be missed.
Hybrid search, four methods in parallel. Meaning-based semantic search (contextual embeddings, 2,048 dimensions), exact-term keyword search (BM25), and two forms of knowledge-graph search that follow the relationships between concepts, not just matching text.
Reciprocal Rank Fusion. The methods' ranked results are fused with Reciprocal Rank Fusion, the industry-standard technique where passages that multiple independent methods agree on rise to the top.
Neural re-ranking. A dedicated re-ranking model reads the query and each top candidate together and re-orders by true relevance, followed by confidence weighting. Duplicates are merged along the way.
Recursive search mode (RLM). The course-conversion pipeline can run retrieval in a Recursive Language Model mode: AI agents explore the document tree (scanning, previewing, searching) and spawn focused child searches, merging what they find into context no single flat query could assemble.
Claim-level grounding (strictest mode). The storyboard pipeline grounds content not in passages but in atomic claims that carry their provenance. Unsafe or conflicting claims are filtered out before ranking; every grounded sentence is then challenged by a panel of three independent AI skeptics (refute-by-default), and citation integrity is enforced by database-level checks.
Retrieval quality is measured. Retrieval runs are scored on faithfulness, answer relevancy, and context precision, logged to an observability platform, so search quality is a tracked metric, not an assumption.
These mechanisms come from the advanced content pipelines (document intelligence, course conversion, and storyboarding) where the retrieval bar is highest. The point for customers: "the AI found it in your documents" is backed by a genuinely engineered search stack, matched to the difficulty of the job.
06 · The temperature dial: creativity is a setting we control per role, not a mood
"Temperature" is the industry's creativity control: near zero, a model is precise and repeatable; higher, it explores. In today's platform, authors have a literal Temperature (creativity) slider on generation prompts, wired directly to the model, alongside companion sampling controls. In SimGate 2.0, nearly every specialist agent runs at a temperature engineered for its job — set in its definition and version-controlled like code.
0.1 — Classifiers. Interpreting an author's edit request must be exact, never inventive.
0.2 — Routers, planners, operation shapers. Decisions and structured output, run cold.
0.3 — Learning-design generators. Briefs, objectives, content maps: grounded prose with a little range.
0.4 — Scoring designer, page & artifact generators. Creative structure under strict rules.
0.5 — SME interviewer, teacher & coach designers. Natural conversation, on task.
0.6 — Cast, phase & decision designers. Scenario craft benefits from imagination.
0.7 — Character author. The one role told to avoid clichés, given the most creative rein.
The pattern to point at: the closer a role sits to facts, structure, or your money, the colder it runs. Creativity is spent only where it belongs — narrative and characters — and even those outputs still pass the same validation and human review as everything else.
07 · Behind-the-scenes prompting: opinionated instructions, managed like source code
What each agent is told to do is not a casual prompt someone typed once. Every agent's instructions live in a versioned definition file that is schema-validated at startup, carries its full change history as an audit log, and is measured against the benchmark suites, where a recorded baseline flags any regression. The instructions themselves are deliberately opinionated: they encode learning-design and quality doctrine, not just a task description. A few of the rules written into the agents, verbatim in spirit:
"Never invent component types that don't exist." — the Builder agent, which must discover what exists, not imagine it
"Judge separately whether the request is destructive, and bias conservative." — the Planner, where a cautious destructiveness call is what triggers the human approval card
"Choose exactly one operation, and prefer the narrowest one that does the job." — the Operation Router, favoring small, targeted changes over sweeping rewrites
"Objective weights must sum to exactly 1.0." — the Scoring Designer, where assessment math is held to hard arithmetic rules at design time
"There is no single 'correct' answer." — the Decision Designer, built for real managerial judgment, not quiz-style gotchas, by explicit instruction
"Cite sources by id." — the Artifact Generator, where citation is an instruction, and provenance is recorded regardless
"Ask one focused question at a time." — the SME Interviewer, so expert knowledge is drawn out methodically, not dumped
"You collaborate; you don't take dictation." — the design partner persona: the agent is instructed to push back when a request conflicts with your design system, and to ask rather than assume
Beyond the rules: content generators carry embedded quality rubrics in their instructions; building agents are taught with worked golden examples — complete, correct operation sequences demonstrating canonical patterns (use approved design values, discover real assets, never paste raw values); the live vocabulary of your project (tokens, fields, tools) is regenerated into the instructions at request time so they are never stale; and every agent declares a fallback model chain, so a provider outage degrades gracefully instead of failing your authors. On iteration turns, the instructions themselves change: the agent is told this is an edit, to make the minimal targeted change, and, if the platform rejected anything last turn, to fix that first.
08 · Context management: before every AI turn, a briefing pack assembled by the platform, not the model
A model is only as accurate as what it's looking at. So the platform assembles each agent's working context deterministically, every turn:
The live state of the work. The current draft or page is re-described from the actual data (components, fields, structure, certification status) so the AI reasons over reality, not its recollection of it.
Your enabled sources. The documents your author toggled on, and for grounded generation, the retrieved passages labeled by file.
The approved vocabulary. Your live design tokens, real component fields, existing library items — regenerated from the source of truth at request time, so the AI's menu is never stale.
Last turn's mistakes. If the platform rejected any of the AI's operations last turn, those errors are placed in the next briefing with instructions to correct them first. Self-correction is built into the loop.
Project memory. Decisions, preferences, and corrections your team has made, bounded and summarized, readable by the AI but never writable. A designer overriding the AI's choice repeatedly becomes a standing instruction.
Turn-aware guidance. The AI is told whether this is a first draft or an iteration. Iteration turns are instructed to make minimal targeted changes, never to start over.
Conversation history is tracked server-side per conversation, and memory digests are size-bounded by design: the platform decides what the model sees, in what form, at what size.
09 · The human in the loop: not a checkpoint at the end — a conversation the whole way through
It would be easy to hear "human oversight" as a final review step. It isn't. The entire authoring model is a turn-by-turn collaboration where the human is present before, during, and after every generation, and the platform is built so the AI literally cannot proceed past the moments that need a person.
Before generation
Humans supply the raw material: uploads, the structured SME interview, pasted references.
Authors curate the source set, toggling documents on or off at any time.
Workflows open with human input first: a simulation build starts with a vision form the author fills in (topic, objectives, duration); several content workflows open with a short required-input form (who you're training, and in what industry) before drafting.
The agents are instructed to ask rather than assume when a request conflicts with the design system or is underspecified.
During generation
Everything streams live into the author's workspace, each step's progress visible as it happens, with results rendered to the canvas as the turn resolves.
Multi-step or destructive plans stop mid-turn on an Approve/Cancel card; the run is parked until the human answers, and Cancel means nothing was applied.
Design-system changes surface as before/after proposals awaiting explicit confirmation.
The AI can't start over your unsaved work, and its changes merge with yours rather than overwrite.
After generation
Every turn ends with an outcome-honest report: what was done, what failed, nothing glossed.
Authors verify provenance, tracing which sources fed the piece, and click citations through to the documents.
Everything is editable in place, undoable in one step, and journaled.
Publishing is a deliberate human act: the author inspects the live result and chooses to publish; certification failures block it.
The result is a rhythm customers recognize from working with a good human team: brief → draft → review → refine, with the platform enforcing that no step skips the person. That's the "human + AI" differentiator in concrete, checkable terms.
10 · Guardrails: what the AI structurally cannot do
Can't write directly. The AI only submits structured operations; the platform validates and applies them. Invalid references, such as a made-up field or an unknown token, are rejected with a precise explanation the AI must act on, including a "did you mean…?" suggestion whenever a close valid value exists.
Can't go off-brand. Approved design values are baked into the AI's tools as the standard inputs; a value outside your design system is accepted only when explicitly flagged as a one-off exception, never disguised as a brand value. Design-system writes fail closed when the design system can't be read.
Can't change your design system. Read-only to the AI. It may propose a change as an explicit before/after; only human confirmation applies it. Core brand fields are excluded even from proposals.
Can't bypass your approval. Multi-step or destructive plans pause on an Approve/Cancel card. Publishing is a deliberate human decision on top of automated certification.
Can't overwrite your work. It can't run while you have unsaved edits; its changes merge with yours, and a genuine conflict stops the save rather than clobbering either side. Shared enterprise assets fork instead of mutating.
Can't touch learners' scores. Scoring and simulation engines contain no AI. Deterministic execution over authored, validated, fingerprinted content.
Can't hide what it did. Undo stack plus append-only operation journal; certain irreversible powers (deleting library items) are simply not given to it.
11 · Measuring quality: we test the AI the way we test software
Because agent output is structured data rather than free text, it can be measured objectively — and it is, continuously.
Golden benchmark suites
Curated scenarios run the real AI end-to-end and score results on objective criteria: right structure built, only approved values used, certification passed, every operation succeeded — all against a fixed pass bar. A recorded baseline means any regression fails the benchmark gate, and the baseline can only be changed by designated code owners.
Evidence-based behavior checks
A second suite verifies what the agent actually did: which tools it called, with what parameters, with verifiable success. "Probably worked" fails; success must be positively proven.
Certification & visual contracts
Every AI-built component faces the 17-point certification. Key screens are held to committed visual baselines at three levels (structure, geometry, pixels at 1% tolerance), and changing a baseline requires a human to approve the diff.
AI reviews advise, rules decide
AI judges are used too — for visual design quality and test-run evaluation — always as labeled advisors, never as the verdict. We apply the same skepticism to our own AI tooling that customers should apply to anyone's.
12 · FAQ
"How does the AI decide what to include from our materials versus what it makes up?"
Three mechanisms, in order. First, retrieval: for grounded content, the system pulls the relevant passages from your enabled sources and puts them in front of the model, each labeled with its file. The model is answering from your material, not from memory. Second, refusal: if sources are missing, grounded generators stop and say so rather than filling gaps. Third, provenance: every generated document carries a record of which source documents it drew on, which specific passages, which conversation asked for it, which AI model produced it, and when, so the "what came from where" question has an auditable answer, not an estimate.
"Will AI-converted content actually be instructionally sound, or will our own instructional designers just end up redoing it?" (sections 03, 07)
That's the right question, and we'd rather answer it honestly than oversell it. We were early to AI-driven conversion, early enough that most of what came out two years ago wasn't usable. That's exactly why the workflow now runs through multiple rounds where every agent evaluates another agent's work before a person ever reviews it. A typical conversion takes four to ten hours, not twenty minutes; if a tool can hand you a finished course in twenty minutes, that speed is usually the tell that quality was skipped. Customers today rate the resulting content at roughly 70% quality as delivered. Not perfect, and we're candid about that, but ahead of anything else we've seen in market, and it keeps improving as our benchmark suites tighten each quarter.
"Which AI agents are involved, and who reviews their work?" (section 03)
It's not one big AI. It's 24 named specialist agents, each with its own instructions and a creativity setting tuned role by role: a router and planner up front; knowledge-intake roles (SME interviewer, course extractor); learning-design roles (brief, objectives, content map); a six-role simulation design team (cast, phases, decisions, scoring, teacher, coach); and building roles (page and component builders, character author). Review is deliberately not another creative AI: it's deterministic validation and certification, benchmark suites, advisory AI judges clearly labeled as advisory, and a human making the publish decision.
"How does our team's own expertise actually make it into the AI's output?" (sections 02, 05)
Two ways, both traceable. Documents you upload are parsed, split, and indexed with per-passage origin, so the system always knows which file and which location a piece of knowledge came from, and your authors control which sources are active at any moment. Live expertise is captured through a structured SME interview, conducted one focused question at a time rather than a free-form dump, so what your experts know enters the system faithfully and in a form the AI can cite back to.
"Can we control how creative it is?" (section 06)
Yes, at two levels. In today's platform, authors have a temperature slider on generation prompts, wired to the model's actual creativity setting. We run precision roles cold and creative roles warm: classifiers at 0.1, planners at 0.2, scoring design at 0.4, character writing at 0.7. In SimGate 2.0, each specialist agent ships at a temperature engineered for its role, precision roles near zero, narrative roles warmer, and those settings are change-controlled like code rather than left to chance.
"How do you control what the AI is actually told to do?" (section 07)
Agent instructions are managed like source code: each agent's instruction set is a versioned definition, validated against a schema when the system starts, and changed through version-controlled commits. The change history is the audit log. Changes can be measured against benchmark suites with a recorded baseline that flags any regression, so a prompt tweak is visible, attributable, and measurable, never silent. The instructions encode our doctrine explicitly: hard rules (scoring weights sum to 1.0), design philosophy (decisions with no single right answer), safety posture (bias conservative on anything destructive), and collaboration style (push back, ask, don't assume).
"How do you prevent hallucination?" (sections 04, 05)
We narrow where hallucination can matter, then catch what's left. Facts come from retrieval over your sources with refusal on missing material. Structure comes from enumerated vocabularies (real fields, approved brand values, existing components) enforced by the tools themselves. What remains (interpretation, composition, draft prose) is validated on the way in, certified before it's done, and human-reviewed before it publishes.
"Is this just keyword search over our documents, or something more sophisticated?" (section 05)
More sophisticated, and deliberately so. Retrieval runs query understanding first, to work out what kind of question is actually being asked, then searches with multiple methods in parallel (meaning-based semantic search, exact-term keyword search, and knowledge-graph search that follows relationships between concepts), fuses the results with Reciprocal Rank Fusion, and re-ranks with a dedicated model. Our course-conversion pipeline can go further with a recursive mode that explores the document tree itself, and our storyboard pipeline grounds content at the level of individual claims, each checked by a panel of independent AI skeptics before it's used. Retrieval quality itself is measured, on faithfulness and precision, so it's a tracked metric, not an assumption.
"Is human review just a final sign-off, or is it built in throughout?" (section 09)
Built in throughout. The pattern is propose, verify, approve: the AI proposes an operation, the platform verifies it against your real project before it's allowed to land, and a person approves the parts that matter. Humans supply the sources, approve multi-step plans before they run, watch each step land live in their workspace, verify citations, and sign off before anything publishes. The platform enforces this mechanically, not just procedurally: runs pause on approval cards, certification failures block publishing, and the AI can't even overwrite unsaved human edits.
"What happens when the AI gets it wrong?" (sections 08, 10)
Usually the platform rejects the mistake automatically with a precise explanation, and the AI corrects itself. Those corrections are literally placed in its next briefing. What slips past validation still faces human gates: plan approval, and the author's own review at publish time. And anything applied is one undo away, with the journal showing exactly what happened. The AI's own summaries are outcome-honest: if steps failed, the reply says so.
"Is AI grading my learners?" (sections 02, 10)
No. Scoring and simulation logic is authored by your team, validated on the way in, and executed by deterministic engines with no AI in them. Same choices, same score, reproducible for audit, and the published package is fingerprinted so the version you approved is the version that runs.
"Can the AI change our brand or design system?" (section 10)
Not on its own. The AI never changes the design system unilaterally: it can propose a change as an explicit before/after, and only a human confirmation applies it. Core brand fields are excluded even from proposals. Day to day it styles content by choosing from your approved values, the standard inputs its styling tools accept; anything outside them must be explicitly flagged as a one-off exception.
"How do you know quality isn't drifting as you update the AI?" (section 11)
We run the AI benchmark suites against a recorded baseline: any new failure, or a score dropping past a small tolerance, fails the benchmark gate. Raising the baseline is a deliberate, human, change-controlled act, locked to designated code owners, so quality can't drift silently in either direction.