AGENTIX · ENGINEERING LOGARCHITECTURE / 2026
Architecture6 min read

Deterministic where it matters

The hybrid pattern: let the model draft where language helps, let deterministic rules decide where a wrong answer is costly — in VistaGPT and TAFI.

By Agentix Tech · Engineering log

A request splits into a generative drafting lane and a deterministic deciding lane before anything ships

The argument about whether to use a language model is usually framed as all-or-nothing: hand the whole task to the model, or keep the whole task in hand-written code. Both answers are wrong for the same reason. A model is good at the part of the work that is linguistic and ambiguous — reading a vague question, drafting a first attempt, phrasing an explanation. It is poor at the part where a single wrong value is costly and no error is raised. The useful question is not model or no model. It is which part of this task tolerates a plausible guess, and which part does not.

We build to a hybrid pattern that answers exactly that: the model drafts where language helps, and deterministic machinery decides where a mistake is quiet and expensive. Two of our systems make the split visible.

70,641columns VistaGPT checks every draft against
13deterministic stages before any SQL returns
32JSON-schema contracts TAFI verifies per phase
279eval stories TAFI runs to score function

Draw the line at the cost of being wrong

The division is not about difficulty; it is about the consequence of a confident error. Asking what a user means by “spend on this job” is a language problem, and a model handles it well. Deciding which tables to join, whether a row is soft-deleted, and whether a posting path can be NULL is a correctness problem where a plausible-but-wrong answer runs clean and reports a different number with no warning attached. One side wants fluency. The other wants a rule you can read and audit.

Put the model where a good guess is useful. Put a rule where a bad guess is invisible.

VistaGPT, our in-development interface to the Viewpoint Vista construction ERP, is built on this split. The model reads a plain-English question and drafts a query. Then deterministic grounding takes over: a schema retriever, roughly nineteen zero-LLM checks for the ERP’s known traps, and a hallucination gate that verifies every field against all 70,641 real columns. A query that cannot be verified is refused, not returned. The model proposes; the rules dispose.

REQUEST Ambiguous ask plain language GENERATIVE — DRAFT Model drafts reads intent, proposes tolerates a good guess x Deterministic decides rules · schema · contracts no guess allowed Ship or refuse verified only The draft is cheap. The decision is checked.
One request, two lanes. Language work goes to the model; correctness work goes to rules that can be read, run and audited.

The same split, one layer up

TAFI, our AI co-builder for the TechAppForce platform, applies the pattern to building applications rather than answering questions. A planner — the generative half — reads a specification and drafts the steps to build the app. But what the platform trusts is not the planner’s say-so. Each phase must emit a defined shape, and a contract verifier checks that shape against 32 JSON-schema contracts before the next phase runs. A drift detector reconciles step counts; a rule holds that fabricated IDs are rejected rather than accepted.

This is why a green score is not the whole story. TAFI runs 279 eval stories to measure whether the function is right, and that is the generative side being graded. The deterministic side asks a different question entirely: did the system obey its own invariants while producing that result? The two are not the same check, and the costly failures hide in the gap between them.

Concern Give it to the model Give it to a rule
Reading a vague request Yes — language is its strength No
Drafting a first attempt Yes — a starting point, not a verdict No
Does this column exist? No — it will confidently invent one Yes — verify against the schema
Does the output match its contract? No — fluent output can still be malformed Yes — check the shape, reject if not
Explaining the result in prose Yes — phrasing is linguistic No

A model that is allowed to decide what ships will eventually ship a plausible mistake. A model that only drafts, with a rule deciding, cannot.

Why this is not a compromise

It is tempting to read the hybrid pattern as a halfway house — neither fully automated nor fully hand-built. It is the opposite. Each half does the work it is actually good at, and neither is asked to cover for the other. The model is not burdened with guaranteeing correctness it cannot guarantee. The rules are not burdened with parsing ambiguity they were never written for. The seam between them is where the governance lives, and that seam is deliberate.

Being honest about maturity: VistaGPT is in development under internal validation, and TAFI is certified in internal test runs — neither ships with public accuracy scores we have not earned. What the pattern already gives you is an answer to the question every buyer should ask: when this system is wrong, how would anyone know? If the answer is “a rule catches it”, the model can draft freely. If the answer is “it wouldn’t”, the model should not be deciding at all.

When this system is wrong, how would anyone know? See how the split works in practice on the VistaGPT case page and the TAFI product page. To map it onto your own stack, book a call at cal.com/agentix-tech or reach us via /contact.

Work with us

Building a system
that has to hold up?

Tell us what you're building. We'll tell you how we'd architect it, what the eval harness would cover, and what production deployment involves.

AGENTIX TECH · engineering log · Architecture