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.

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.
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.
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.

