The category error. "Isn't this just a shell?"
What most teams have today
Several calculators, a document store of reference PDFs, a system of record, a vendor list, a directory. Each answers its own narrow question, as long as you already know which one to open:
- Which orders shipped to which customer last week? Your ERP or CRM.
- Where is the estimating spreadsheet? Your document system.
- What does this option cost at 10,000 units? A spreadsheet, if you find the right version.
What gets built
The expensive knowledge is different in kind. Audit expectations, customer rules, trade-offs, and who to ask live in standards, transcripts, and senior heads. No system you own can answer:
- What does a passing answer look like to the auditor, regulator, or reviewer?
- Does this customer allow this option, and what does the other one require instead?
- I am about to skip a step. What does that cost me on the audit, and is there stock I should use first?
Not a replacement. Your ERP stays the system of record. Your document store stays the document store. The platform reads from and writes to them only where the engagement scopes it. Nothing is migrated, nothing is duplicated.
Not a wrapper. It does the work between the systems: the interpretation, the cross-referencing, and the "what does this choice cost me." The hours that currently happen inside one person's head.
Two kinds of module, one platform
Every build is assembled from two module types standing on one shared platform. Modules marked proven exist in production today. Modules marked custom are designed and priced per engagement.
Compliance / Audit Helper
Chat, tier self-assessment with a printable gap report, and a browsable rubric.
Regulatory Q&A
Chat, a scope wizard, and a digitized inspection checklist with escalation cards.
Customer Requirements Hub
Per-customer specs, approved options, labeling and delivery rules.
Policy Guidelines Agent
Sustainability, cost, or risk policy applied to a live decision.
Technology Education Hub
Options, trade-offs, and when each one fits, for the decision being made.
Inventory / Surplus Slice
What you already own, before anyone buys new.
Unified Calculator
Replaces N spreadsheets with one chat-and-form hybrid: editable assumptions, help bubbles, compliance prompts at the right step.
Vendor / Supplier Directory
Smart filtering by capability, region, and approval status.
Contacts + Teams / Slack
Routes any unknown to the named owner, with context already attached.
Form to System of Record
Calculator output auto-populates the planning form, which feeds your ERP after a human confirms.
Not just a chatbot. One knowledge base, three ways in
Ask it
Grounded chat. Cited answers in plain language, and a refusal instead of a guess when the question falls outside the loaded corpus. "How do we get to the next tier?" "What do I do on a failed inspection?"
Check against it
A self-assessment walks your scoring ladder and produces a printable gap report: current tier, the red-line warning, and the reviewer's evidence list for every gap. Scope wizards answer "does this rule apply to me?" Digitized checklists end in your SOP's exact escalation card on any failure.
Read it
The entire corpus as a browsable, deep-linkable reference. Every criterion with its requirement, evidence checklist, and practical guidance. It updates the moment your owner publishes a new corpus version.
The chat gets the demo applause. The structured tools are what people open on a Tuesday, and the deep links are how the knowledge spreads through the organization on its own.
Named parts, no magic boxes
The request path, for every module and every user request:
Browser
Gated session, httpOnly cookie, no secrets client side.
Server application
Managed cloud. Assembles the grounded prompt or calculator state and streams back.
Frontier language model
Commercial API, under contractual no-training terms.
Knowledge store
Versioned corpora. No personal data, by design.
- Gate. Shared password during evaluation, your SSO in production. One login, every module.
- Knowledge store and pipeline. One versioned store, N corpora, each with a named owner who updates it without code.
- Grounded-agent framework. Knowledge layer plus rules layer. Every hub is this machine pointed at a different corpus.
- Cross-link bus. Structured tags on criteria let one module fire a prompt inside another. Compliance into the calculator, regulation into the form.
- Help bubbles. Your training videos sliced per field. The right 40 seconds appears next to the input that needs it.
- Audit log and integration layer. Who did what, when. Outbound connections exist only in the final phase, only inside your tenant.
Standard parts, deliberate assembly. The value is the knowledge layer, the cross-link bus, and their governance. Built once, reused by every module in your build.
How it all works together. One person, one decision
Scope
Inputs, volumes, candidate options. The first-pass estimate. The Customer Requirements Hub injects that customer's approved options and rules, the Vendor Directory offers suppliers who can actually deliver the candidate, and the inventory slice checks what you already own first.
Size
The quantitative core: fleet, capacity, cycle, safety stock. A compliance prompt fires with the criterion this step must satisfy and the evidence it needs. The technology hub offers add-on options and their compliance implications. A help bubble plays the 40-second training slice for the field being edited.
Optimize
Trade-offs: cost against policy against risk, and right-sizing. The policy agent runs the comparison your guidelines require and shows the exposure. A compliance prompt says to log this as the documented improvement. A regulatory check runs if anything regulated enters the spec.
Plan
Calculator output auto-populates the planning form. A human reviews and confirms every field before anything is written. Contacts routes any open question to the named owner with context attached.
Record
The confirmed form feeds your system of record, which stays the system of record. The integration layer uses a least-privilege service account, writes only after confirm, and logs every write. Runs inside your tenant, coordinated with your IT, in the final phase.
Today this is several spreadsheets, a document store, and a phone call. In the platform the person moves left to right and the knowledge shows up at the step where it matters: the customer rule at Scope, the compliance consequence at Size, the policy math at Optimize. Instead of being remembered, searched for, or missed.
The step names above are the reference deployment's. Yours are mapped in the first scoping session.
The cross-link bus. How one module fires inside another
Every criterion in a knowledge hub carries structured tags naming the workflow moments it governs. When a tool reaches one of those moments, it asks the platform "what applies here?" and the relevant hub answers, in context, citing its source.
Nothing is hard-coded between modules. Add a criterion, tag it, and it starts firing in the right place. Retire it, and it stops. It is the difference between nine tools and one system, and you can feel it: in the reference deployment, the calculator preview pops the real compliance prompt the moment a tracked step is toggled off. Sample data, real wiring.
Tag schema and resolution logic are licensed IP.
Six hubs, one machine. Why they do not hallucinate
Layer 1: knowledge, one per hub
- Compliance / Audit. Your scoring rubric plus your expert's training transcript.
- Customer Requirements. Per-customer specs, approved options, benchmarks.
- Regulatory. Certification SOP, international standard, training guide.
- Policy. Cost, sustainability, or risk guidelines.
- Technology. Option education and vendor notes.
- Inventory. Live surplus or stock slice.
Each corpus is versioned, curated with its owner, and injected server side. Never editable by the person asking.
Layer 2: rules, shared by all hubs
Binds the model to its corpus: never invent, refuse outside loaded scope, quote the source verbatim where it matters, route unknowns to the named owner. Same rules layer every time, so a hub that passes the test once passes it for every corpus. Construction of both layers is licensed IP. The corpus is cached at the API level, so it is billed once per cache window rather than once per question.
Tested adversarially, not assumed
In the reference deployment, an internal audit-prep hub for a Fortune 500 Tier 1 automotive supplier, 24 realistic questions were fired at the production endpoint before its first internal demo. Three were probes designed to bait fabrication:
- A criterion that does not exist. Refused. It named its exact loaded scope, declined to invent, and offered the human path.
- A real criterion outside the loaded scope. Refused. It distinguished real-but-unloaded from loaded content.
- An off-topic question. Redirected. It declined and offered in-scope follow-ups.
The part no off-the-shelf tool has. The knowledge pipeline
Standards get rewritten. Customers revise their specs whenever they like. Most AI tools would need a rebuild. Here, each hub's named owner updates its corpus through one pipeline serving every hub. No code change, no redeploy, no IT ticket. This is what makes that safe:
Upload
Your domain owner drops in the documents you already maintain: spreadsheets, transcripts, SOPs, standards. No reformatting, no special templates.
Parse
File contents are extracted server side. Nothing executes client side, and nothing leaves the deployment except the model call.
Structure and validate
A proprietary structuring and validation layer converts raw content into the helper's knowledge format, and rejects anything malformed before it can ship. Bad input cannot reach production. Stage 3 internals are licensed IP.
Human preview
Your owner reviews the structured result on screen before anything goes live. Nothing publishes without a human decision.
Versioned publish
One click writes a new version to the knowledge store. The helper serves the new content within about 30 seconds. The prior version remains recoverable.
Governance property. The model can only know what passed validation and human review. Its knowledge has a change log, an owner, and a rollback path.
Per-module data classification. What touches what
Knowledge hubs
Internal methodology: rubrics, procedures, customer requirement documents, training transcripts. No customer records, no personal data. Hosted during evaluation, then inside your tenant in production.
Workflow tools
User inputs such as quantities, options, and assumptions, plus vendor and internal-contact business data. Anything your policy classes as confidential stays inside. Evaluation uses sample data only. Real data runs inside your tenant, never on external hosting.
Integration
Writes confirmed planning records into your ERP or equivalent. Final phase, inside your tenant, coordinated with your IT. Never from the evaluation deployment.
The never list, across every module
No confidential records leave your environment
Stated in the engagement agreement and enforced by architecture. Confidential inputs only ever run inside your tenant.
Model API keys never reach the browser
Server-side environment variables only. No client bundle contains them.
The model provider does not train on your traffic
Commercial API terms. Contractual, not a toggle. Enterprise zero-retention available where required.
No writes without a human confirm
The system-of-record write happens only after a person confirms the form, under a least-privilege service account, and every write is logged.
Conversations are not stored
No chat database. The audit log records actions and writes, not the content of questions.
Security model, layer by layer
| Layer | Evaluation deployment | Production in your tenant |
|---|---|---|
| Transport | TLS 1.2 or better on every hop: browser to server, server to model API, server to knowledge store. | Unchanged. |
| Access | Password gate issuing an httpOnly session cookie, scoped to your evaluation group. | Your SSO (Entra ID, Okta, Google). The app is built to swap gates without rearchitecting. |
| Secrets | All keys in server-side environment variables on the host. Nothing in source, nothing client side. | Same pattern inside your tenant, under your key management. |
| Source code | Private repository. Copyright notices in every file. Access individually granted. | Licensed artifacts transfer per the engagement agreement. |
| Storage | Versioned knowledge store holds curated guidance only. No personal data, no data from your systems. | Unchanged in kind. Data residency configurable to your policy. |
| Integrations | None. The evaluation deployment has no credentials to any of your systems. Nothing to leak, nothing to pivot from. | Final phase only: form to system of record via a least-privilege service account, write after confirm, every write logged. Scoped with your IT. |
| Revocation | Kill switch. Hosted access, so all access can be revoked same-day from the deployment. | Control transfers to your IT with the production handoff. |
Honesty as the security posture. The evaluation gate is deliberately evaluation-scope. It is appropriate for a gated demo of non-sensitive content, and it is named as such rather than dressed up.
Your security reviewer should find every claim here exactly as strong as it is, and no stronger. A pre-answered security questionnaire is available on request.
Not a product you configure. A system built for you
The corpus
Your standards, procedures, transcripts, and worked examples. Curated with your domain expert, not scraped.
The rules
Scope boundaries, refusal behavior, citation style, and escalation owner, tuned to how your reviewers actually judge answers.
The gate and the tenant
Your SSO, your cloud or Copilot environment, your data-residency policy for production.
The voice and the brand
Your name on it. Suggested prompts, tone, and UI written for your users' vocabulary.
The test pass
An adversarial question set built from what your people actually ask, run before every demo and every knowledge update.
The machine underneath
The two-layer grounding architecture, the knowledge pipeline, the security model, and the documented handoff path. Proven once, reused for you.
This is why a custom build lands in weeks, not quarters: the machine is done. The engagement is the knowledge work.
Hosted to prove it, handed over to run it
First knowledge hub
Your highest-pain rubric or standard. Proves the pattern on your content. In the reference deployment the second hub then shipped in days on the same platform.
Second hub
Same machine, new corpus. Typically customer or regulatory requirements. First fully paid phase.
Unified calculator
Your spreadsheets become one chat-and-form hybrid. Consumes the cross-link tags the first hub already carries.
Supporting hubs and tools
Remaining hubs, vendor directory, contacts routing. Each on the same platform.
System-of-record integration
The only outbound write in the system. Inside your tenant, with your IT.
Knowledge transfer and IT handoff
Walkthroughs, documentation, and deployment support until your IT runs it alone.
The production path
- Code delivered to you. Each phase lands in a private repo transferred to your control on completion, under the license terms. API accounts, keys, and usage billing move with it. Nothing stays tied to the builder's account.
- Your IT does final deployment. Rebuilt inside your own cloud, Copilot, or equivalent AI environment from a step-by-step handoff doc. The model is a swappable component behind one interface. The corpus, tools, and tests carry over unchanged.
- Hosting is a proving ground, not a destination. The external deployment exists so the pattern can be validated with your real users before it goes inside the walls.
Each phase stands alone. Every phase is a working deliverable on the shared platform. Stop after any of them and keep everything built so far. That is the architectural reason the platform layer comes first, not a sales line.
What we tell you before you ask
What is actually built
In the reference deployment, two of nine modules are live, each with chat, structured tools, and a browsable reference. The rest exist as clickable previews: amber-bannered, watermarked, sample data only. Previews are deliberately impossible to mistake for working software. Every terminal action is intercepted with a "just a preview" notice. They are designed and priced per engagement, not built.
Access during evaluation
Shared password, evaluation group only. No integrations, no confidential data. Production swaps in your SSO. Calculators and system-of-record writes run only inside your tenant.
Latency, measured
8 to 25 seconds is typical for a cited answer in the reference deployment. Published numbers come from live production tests, not lab estimates. Yours get measured the same way.
What this page is, and is not
This describes behavior, not blueprints. The prompt architecture, the knowledge schema, the cross-link tag design, the structuring and validation internals, and the curation methodology are licensed intellectual property. They transfer with a formal engagement, not with a page and not with a demo login.
That is not evasion. It is the same reason this can be shown to any audience safely. What you can evaluate is what it does, measured and in production. What you license is how.
Built to be auditable, not magical.
Where this pattern fits. It is a shape, not a sector
The qualifier is not your industry. It is a shape with four parts, and if all four are present the pattern fits you regardless of what you make or sell.
There is an authoritative written thing
A standard, spec, rubric, policy, code, or manual. It exists and it is correct. Without this there is nothing to ground against, and you have a documentation project first.
There is a gap between the document and the decision
Reading the standard does not tell someone what to do at 2:15 on a Thursday, three fields into a form, with a deadline.
There is a bottleneck expert
One or two people who can close that gap, and everyone already knows their name.
Getting it wrong costs something real
A failed audit, a violation, a rework, a claim, an injury, a lost contract. Without this nobody will fund it, and they are right not to.
Reference deployment
"What evidence does the auditor want for criterion 3.2?"
Audit and supplier standards. Self-assessment with a printable gap report.
Gowning & deviations
"What does gowning qualification require before I can enter Suite B?"
GMP SOPs and cleanroom procedures. Deviation checklist escalates to QA in Teams.
Adverse event reporting
"Does this complaint need to be reported as an adverse event?"
Quality-system procedures. Decision-tree wizard that refuses when the case is genuinely ambiguous.
Policy at the bedside
"This patient meets two criteria that point different directions. Which policy governs?"
Infection control, medication, documentation and consent policies. Cited answers, paged escalation when the policy is silent.
Pre-bind and appetite
"Can we bind this policy without a flood certificate?"
Underwriting guidelines and compliance manuals. Pre-bind checklist, unknowns routed to the named owner.
Isolation and permits
"What are the isolation steps before I open this panel?"
Safety and lockout-tagout SOPs. Inspection checklist ending in your own STOP card on any failure.
Stacked requirements
"Which requirements flow down to this supplier, and which do not?"
Your quality manual plus each customer's supplier requirements. Two corpora, answered where they interact. Controlled material stays in your tenant.
Deviation while the line runs
"A control point ran out of spec for eleven minutes. Deviation, hold, or recall?"
HACCP plans, preventive controls, allergen program. Digitized deviation record your audit scheme already requires.
Spec against code
"The spec says one thing and the local amendment says another. Which governs?"
Project specs, code amendments, and your own RFI history, which is a documented interpretation nobody can find twice.
Policy, not judgment
"Does this engagement trigger an independence issue?"
Methodology, independence policy, engagement acceptance. Frees the judgment work, which is the part clients pay for.
Grant allowability
"Is this cost allowable on this award?"
Procurement policy plus the terms of each specific award. Different terms per award is exactly what a versioned multi-corpus store is for.
Which rule applies
"Does this shipment classify as hazardous, and what does that change?"
Carrier requirements, routing guides, dangerous goods procedures. A scope wizard rather than chat: decisive, cited, fast.
And where it does not fit. When there is no authoritative document, there is nothing to ground against. When the question is pure judgment, a grounded system should refuse, so you paid for a refusal. When the question is a record lookup, your system of record already answers it. And when nobody will own the corpus, it goes stale within a year and people stop trusting it.
That last one is the only real prerequisite, and it costs nothing to check before you start.
The six things they will ask
- What does the status quo cost us? Run the math yourself before the meeting: experts interrupted, times hours per week, times working weeks, times sites, times loaded rate. One number, and it is yours rather than a vendor's.
- What happens if it fails? Each phase is a standalone deliverable. Stop after any of them and keep what is built. Hosted access is revocable same-day.
- What does security need to review? Section 10 above, plus a pre-answered security questionnaire on request. Bring both to the meeting rather than after it.
- Who owns it after it ships? Your team. The code transfers to your repository, keys and billing move with it, and the corpus is updated by a named domain owner through an interface, not by an engineer.
- Why not wait for our platform vendor? A general assistant and a corpus-bound hub with a rules layer that refuses are different jobs. Keep both.
- What do we start with? The standard that burns the most hours weekly, with one named owner, that can begin without a legal review. Not the most impressive demo.
Want the fill-in-the-blank version of the one-page internal memo? Email me and I will send it, along with the full architecture deck including the limits page.