Plain-language architecture guide · Updated 18 September 2026

Objective Purpose: Turn a human request into a more precise AI request.

Prompt Precision takes an ordinary-language request, associates it with relevant ontologies, graph material and structured requirements, then prepares a better-grounded request for an inference model. Instead of asking a model to guess what “help with this agreement” means, the system can supply the relevant concepts, selected records, requested output shape and limits alongside the person’s words.

Its practical objective is to avoid spending model time, energy and memory on irrelevant or repeatedly reconstructed context, while improving the usefulness of the response for the task at hand. If measured and validated, that can make capable local inference practical on more personal machines and improve AI economics across an ecosystem: less waste per request, more useful work from the available hardware, and clearer grounds for deciding when a more expensive model or service is actually warranted.

The core idea

Language in; structured meaning and relevant context out.

1 · Interpret the request

The routing component reads the request and any declared domain focus, then retains every matching in-scope ontology, its stable context namespaces, and a routing brief for inference. If no ontology matches, it retains the full in-scope set rather than imposing an arbitrary shortlist.

2 · Associate graph material

The chat route combines the routing result with available retrieval, files, session context, semantic profiles and graph information. The conditioning compiler can further select evidence by declared graph scope and sensitivity ceiling.

3 · Render the inference request

A structured profile can specify an objective, requirements, output contract and budget. The compiler renders those with selected evidence as a native ChatML request, plain request, or MCP envelope for the model to process.

Current precision boundary: ontology routing presently uses request keywords, ontology names/tags and a few domain hints. It is useful routing, not a claim that the software fully understands natural language or has solved semantic interpretation. The time, energy, local-machine and economic benefits above are objectives to be measured against real tasks and hardware, not results asserted by this page.

Logic and Guardian layers

The prepared request can be connected to rules the model does not get to invent.

Prompt Precision prepares meaning and context for inference. QualiaDB’s logic systems then provide ways to represent and evaluate defined conditions around that work. They are not claims that an LLM has proved something merely by producing prose.

Rules, duties and permissions

Deontic logic represents obligations, permissions and prohibitions. N3 rules can be compiled into these norms, including rules that defeat a weaker permission. This allows an agreement or workflow to state what may, must, or must not happen as structured data.

Time, knowledge and disagreement

Temporal logic can express conditions across a sequence of events. Epistemic logic distinguishes knowledge and belief. Paraconsistent routing can isolate conflicting statements instead of treating a contradiction as permission to infer anything at all.

Guardian and deterministic gates

A Guardian is a human-authorised co-signature path for a defined agreement or protected action—not an autonomous AI supervisor. A proposed transaction can remain suspended until the required consent token arrives, or be denied. For graph-writing turns, the sieve and N3/SHACL gates can reject output that does not meet the required structure.

How this connects: a prepared request may select the relevant ontology, graph facts, agreement terms and output structure. The applicable logic or Guardian rule then evaluates the defined operation or graph action. It is not correct to say that all of these systems automatically run on every chat message; a workflow must explicitly select and wire the rule it needs.

Guard, evaluate, improve

Prompt Precision is useful only when the response can be checked against the prepared request.

Prepare semantic context and expectations → Sentinel checks the permitted inference/action path → model generates → evaluate the response against the expected result and requirements → retain, revise, or reject the profile

Webizen Sentinel: enforce the route

Before inference, the runtime validates the requested intent. For graph-writing turns it enables the structured-output sieve and restricts the requested predicate scopes. During verified decoding, logit summaries can pass to the Sentinel over a wait-free control path; an anomaly can issue DenyRollback before the next token step. In FastVerify mode, the same mid-decode intervention is skipped and graph/CML verification runs before the turn is finalised.

Response evaluation: test usefulness

A Prompt Precision task manifest can state an expected outcome and whether citations and constraints are required. The evaluator records accuracy, citation fidelity and constraint satisfaction, then compares a prepared profile with a baseline on train/dev work and a separate held-out set. This is how the system can learn whether additional semantic context made the result more useful—not simply longer or more technical.

What the current evaluator does—and does not—decide

The current generic scorer checks exact or contained expected text plus declared citation/constraint flags. It is a reusable evaluation seam, not a universal judge of truth or social usefulness. Real domains need their own task evaluator and human review; the present optimiser’s model-output scoring is still simulated, so it must not be presented as live performance evidence.

Concrete graph-output gate: before a generated result may be committed to the semantic graph, the current runtime rejects an output with no provenance Quin or one that exceeds the configured token limit. Those are enforceable admission conditions; they are not proof that every generated claim is correct. The expected-usefulness evaluation is the complementary process that tests whether a prepared request achieved its intended result.

What this is about

From “write something” to a useful, reviewable job brief.

Say what is wanted

Start with the outcome: compare options, prepare a first draft, explain a record, or find gaps in a plan. State what a good result looks like and what the AI must not decide on its own.

Bring the relevant material

Attach or select the plans, notes, records, shared concepts and prior work that matter. The system can assemble those materials as working context instead of asking people to re-explain the same project every time.

Check before relying on it

Make uncertainty visible, distinguish observations from suggestions, and keep the final decision with accountable people. Reusable profiles can make this kind of job brief consistent without pretending that the AI is an authority.

Prompt Precision inference preparationA person’s natural-language request is routed to relevant ontologies and graph context, rendered as a structured inference request, and passed to a language model. Prompt Precision prepares a graph-informed request for inferenceNatural language → ontology and graph associations → structured model context → inference 1 · Human request“Draft a guardianshipconsent agreement”2 · Semantic routingRelevant ontology, termsand graph namespaces3 · Prepared contextRequirements, selectedevidence and budget4 · Model inferenceA more specific promptfor the selected model

Why this matters

The point is to make useful work easier to repeat, improve and explain.

For communities and organisations

Use the same agreed brief when work is repeated: what a planning summary should cover, how an incident timeline separates facts from hypotheses, or what a policy draft must leave for human approval. This reduces rework without replacing responsibility.

For policy and governance

Make the purpose, source material, assumptions and review point visible. This gives people something concrete to question and change, instead of leaving consequential instructions hidden in an improvised conversation.

For technical teams

Represent the job brief as structured, versioned data where that helps: shared concepts, rules, source links, output checks and resource limits. That enables a team to test whether a profile helps rather than relying on the confidence of its prose.

What has been implemented

A reusable way to prepare an AI request, rather than starting from scratch each time.

1 · A structured job brief

The core compiler accepts a profile with an objective, requirements, an output shape, a budget and available evidence. Each requirement is labelled as an executable rule, an evidence obligation, or guidance—so the system does not pretend every instruction is enforced in the same way.

2 · Select what can fit

Typed request parts rank mandatory instructions and the person’s request above optional tool definitions, evidence and history. If the mandatory material cannot fit, the compiler rejects the request. It does not silently cut the actual request in half.

3 · Keep versions honest

A model-specific contract is bound to a profile ID, version and specification identity. If those no longer agree, it is not applied. A profile can be promoted, replaced or rolled back, so a team can stop using a version that proved unhelpful.

Current integration boundary (what runs now, and what remains): a conditioning profile submitted to the local POET API is compiled, filtered by its declared disclosure scope, rendered as the request used for both ordinary and streamed local inference, and returned with a plan receipt. Direct desktop chat currently uses a simpler integration: it preserves the final user request, adds the active profile marker, and reduces earlier assembled context to fit a byte cap. The full typed compiler is not yet carried through every desktop, HTTP, Ollama and MCP route.

How it works in practice

A simple discipline for getting better results over time.

Purpose → relevant material → a clear task → AI-assisted draft or analysis → human review → a reusable, improved job brief

  1. Make the purpose visible. “Help with our project” is not enough. Say whether the work is to compare options, produce a draft, find contradictions, or explain an existing record. A good brief tells the AI where it can help and tells people what remains their responsibility.
  2. Use the right material, not all material. Bring in the documents, concepts and earlier decisions needed to understand the work. This is both an efficiency question and a quality question: irrelevant context can make an answer slower, costlier and less useful.
  3. Specify the shape of a useful result. Ask for a comparison, timeline, checklist, draft or explanation. Require uncertainties and disagreements to be shown rather than quietly smoothed over. That gives a reviewer something concrete to check.
  4. Keep the relevant people in charge of consequential action. An AI can assist with research and drafting. The requester, or people acting under an explicit mandate, decide whether to publish, approve, spend, commit, or change a real-world arrangement. The platform operator and the model are not a substitute principal.
  5. Learn from the result. If the brief caused omissions, confusion or unnecessary cost, improve it and retain the useful version. Over time, a team can develop reusable job briefs for recurring work rather than relying on whoever happens to write the cleverest prompt.
For implementers: what needs to be enforced in software

The authoring idea becomes dependable only where the runtime enforces its resource and output limits. These are engineering requirements, not policy language.

actual_input_tokens ≤ profile.input_tokens
actual_input_bytes ≤ profile.max_bytes
actual_input_tokens + reserved_output_tokens ≤ supported_context_tokens
planned KV + recurrent state + scratch + resident weights ≤ device budget
host expert banks + pinned staging + other host state ≤ host budgets

The same final token IDs must be counted and executed. Tool and repair rounds share cumulative limits; output reserve is not part of input-token usage. The current direct-chat lowerer has only part of this job, so its limits should not be misrepresented as a complete control system.

Affordable personal-computer target · not yet demonstrated

Useful local AI should not require a data-centre.

The practical aim is for people and small organisations to run useful AI workflows on affordable personal computers, with a modest graphics card where available and a clear CPU-only path where it is not. One proposed reference target is Qwen3.6-35B-A3B NVFP4 on an RTX A2000 12 GB. That is a test case—not a requirement that every person own that card.

A workable design can use system memory, bounded graphics-memory slots and scheduled transfers rather than assuming every model weight permanently fits in graphics memory. It must still state its actual hardware conditions, resource use and response quality honestly; “local” is not a substitute for evidence.

The target needs Qwen's actual hybrid attention and recurrent state, expert routing, shared experts, mixed quantisation formats and an Ampere-compatible dequantisation path. NVFP4 checkpoint storage must not be confused with a requirement for native FP4 hardware. Prompt compaction can reduce input work; it does not replace weight offload.

Acceptance compares the same checkpoint, prompts, context, output reserve, modality and concurrency. Record cold load, TTFT, prefill/decode throughput, tail latency, host/VRAM peaks and held-out quality. Loading alone, shorter answers or a silently reduced context do not establish parity. Other model and multimodal capabilities need their own explicit validation rows.

Local AI on an affordable personal computerA personal computer with system memory, optional graphics hardware and a CPU-only fallback runs a local model, followed by human review. Useful local AI should not require a data-centreA modest graphics card can help; CPU-only routes and honest resource reporting still matter. Personal computerSystem memory · optional GPUCPU-only fallbackLocal modelBounded memoryChosen evidencePerson reviewsChecks and correctsMakes the decision

Worked examples

What this component does with an actual request.

These examples match the implemented conditioning code. They show request preparation and control; they do not claim that a model’s answer has been independently validated.

“Draft a guardianship consent agreement”

Association: the routing tests select the installed Legal Commons ontology for terms such as “guardianship”, “consent” and “agreement”. Prepared context: the inference packet receives the routing brief and legal namespace hashes, alongside selected retrieval and session material. The LLM receives more than the bare sentence.

“What does this patient fever indicate?”

Association: the routing tests select the installed clinical/SNOMED ontology from terms such as “patient” and “fever”. Prepared context: the selected ontology supplies domain context and namespaces; graph retrieval can contribute relevant records. It is a routing aid—not a diagnosis, and not a substitute for clinical judgement.

A repeatable technical review

Association: a structured profile states the objective, requirements and output contract; selected evidence is copied only when it fits the declared scope. Prepared context: the compiler renders these as an explicit system/objective/requirements/evidence envelope for native ChatML, plain inference, or MCP. That gives the model a consistent, inspectable request shape.

Three implemented prompt-precision functionsThe conditioning code selects bounded context, chooses evidence within authority scope, and applies compatible model-specific request contracts. Three useful controls in the implemented conditioning componentKeep the required request · select authorised evidence · apply only a compatible model contract Bounded contextInstruction + question always stayOptional context fits if possibleOtherwise it is left outScoped evidenceCheck graph scope and ceilingCopy authorised evidence onlyRecord missing requirementsCompatible contractMatch profile, version and specBound context and outputReject stale configuration

Before any profile is adopted

Promote a contract only after testing it against the unmodified route

Compare the same task

Run the ordinary assembled prompt and the contract-lowered prompt against the same held-out task set. Preserve the same model, chat template, evidence, output allowance and concurrency. Otherwise a smaller answer can be mistaken for an improvement.

Measure the route actually used

Record whether the local/native, Ollama, HTTP, or remote MCP route ran; its model/template identity; rendered bytes and actual token counts where available; latency; memory; output checks; and task quality. Unknown measurements must remain unknown.

Make activation reversible

The model-precision registry can bind an active profile/contract to a model and clear it on rollback. Promotion should retain the model, profile version, test set and measurement record so a later regression has a clear comparison point.

What remains to be connected

The code-level account is in the source evidence map. The target shared design is in the conditioning architecture and implementation contract.