The rule behind this page is two words: be prepared. Every part of the AI platform has been specified before the build, from the servers to the chat window, because a guardrail retrofitted into a working pipeline usually forces the whole thing to be restructured. Designing the machine whole costs a document. Retrofitting costs the machine. Most of the pieces here are defined, not built, and the page says which is which throughout.
One machine, many projects
Several projects on this site are organs of this one body. The evaluation feeds the model roster. The warehouse exposes the one identifier-stripped schema any model may see. The job scheduler will fire the document scans that keep the index fresh, and the skills library will wrap the recurring routines. The private AI program is the machine’s own page, carrying what is built and what is planned without blur.
What the machine does
A staff member asks a question in plain language. The system retrieves the most relevant passages from our own material through a governed gateway that releases only what that person may see, hands them to a locally hosted model, checks the answer, and returns it with citations. The pattern is retrieval-augmented generation, RAG: the model answers from what was retrieved, never from its own memory. No route carries protected health information to a cloud model, and nothing changes a system of record without a person approving it.
Built like an operating system
An operating system gives every program the same kernel, drivers, file system, and logs, so no program re-implements them. This platform is built the same way, and stacked as layers it looks like this:
The machine also writes five logs, kept apart on purpose because each has a different reader and a different retention, and everything that tunes behavior, the prompts, the thresholds, and the routing table, is versioned configuration changed without a code deploy.
The kernel rule
The governed gateway is the one component allowed to touch the data, and it speaks the Model Context Protocol, MCP, the open standard for connecting AI tools to data. Its role: check every request, refuse anything unregistered, treat anything unclassified as clinical, and log every call. Retrieval, the indexing pipeline, and any future client all go through it, because its database login can reach the warehouse’s identifier-stripped schema and nothing else. A model in this design generates text and holds no other power.
A question is a process
The answer path is ten fixed stages, run as a plain governed script first and moved onto a workflow engine (LangGraph) only when the branching outgrows it, a refactor with the same tests rather than a redesign. The stages that are not needed yet, the human gate above all, exist as deliberate no-ops so that filling them later is configuration, not surgery. Drawn as the flow a question takes:
%%{init: {"flowchart": {"nodeSpacing": 18, "rankSpacing": 34}}}%%
flowchart TD
Q["A question arrives with<br/>identity and domain"] --> R{"Role allowed<br/>this domain?"}
R -->|no| X["Declined and logged"]
R -->|yes| T["Retrieve from the index<br/>under the asker's permissions"]
T --> C{"Enough relevant<br/>material?"}
C -->|no| Y["Clarify or decline;<br/>thin ground never generates"]
C -->|yes| G["Generate on the local model<br/>the router picked"]
G --> V{"All checks pass?<br/>scrubbed and cited"}
V -->|no| F["Retry once, fall back,<br/>or decline"]
V -->|yes| A["Answer, with citations"]
X --> L["Every outcome<br/>is logged"]
Y --> L
F --> L
A --> L
The confidence check exists because of a measured failure: asked a question the material could not answer, the model answered confidently anyway, and prompt hardening only partly fixed it. The evaluation tells that story in full; the design assumes it will happen again.
What runs today
The isolated model server runs in production with its measured two-model roster, the routing table is in daily use, the first doorway is live between the coding assistant and the local models, and the evaluation harness that gates every model change has already reversed one of its own decisions. The index, the answer graph, the gateway, and the chat interface are designed, with their contracts fixed and the build order set. A second knowledge domain for everyday staff questions is designed to share the same machine. Status moves only on evidence: a part is called built when its gate is met, never when its code is merged.
Read next: the journey, how I got here one tool generation at a time.