WunderOS Means No NLP in the Hot Path
Abstract
A high-assurance query substrate should refuse natural-language-to-query translation at its protocol boundary and require agents to emit structured queries directly. WunderOS does this, and the refusal runs deeper than the query language. No natural-language processing sits in any hot path of the system, protocol or runtime alike. Nothing translates prose into structure on the way in and nothing softens structure into prose on the way out while an agent waits.
This is not an argument against models. PLRN-022 fixes where models belong: wherever they preserve the quality that matters at the least cost and least stochasticity available. What WunderOS refuses is a particular use of models, the reflexive one, in which a frontier API call is inserted between an agent and a database because the year is 2026 and that is what data products do.
The objection is to position, not to existence. A model can work for the agent. It cannot stand in the doorway.
The sloppy default that WunderOS refuses
The 2026 default is chat boxes everywhere, most of them either direct wire to frontier model API or some form of text2X. Ship a vector store and you must ship text2SQL. Ship a graph and you must ship text2SPARQL or text2GQL. Ship anything at all and someone will ask why they cannot just talk to it; and the honest answer, which is that they can but the results will be worse and cost more, is not an answer the market currently accepts. So the translation layer ships anyway, usually as a thin wrapper around whatever frontier model is fashionable, and the failure modes ship with it.
The wrapper looks like a feature. It is better described as a confession. A chat box bolted onto a query surface says that the structured interface was never expected to have users, so nobody finished building it.
We finish building it. Agents are the users, agents speak structure natively, and the substrate treats that as the normal case rather than the power-user case.
Three reasons why for our refusal
Our refusal is empirical before it is architectural.
First, structured targets beat unstructured ones on enterprise data even when the model is identical. Sequeda, Allemang and Jacob put GPT-4 zero-shot text2SQL on an insurance schema at 16 percent accuracy and the same questions, over a knowledge graph, via text2SPARQL, at 54. Allemang and Sequeda then pushed further with Ontology-Based Query Check, a typed-repair loop against the TBox. The pattern holds across the literature: when the model emits into a grammar rather than into English, more of what it knows survives the trip.
Second, program-aided reasoning beats free-form reasoning over the same content. PAL and Program of Thoughts route arithmetic through an interpreter and outperform chain-of-thought on the same benchmarks. Chain-of-Table does the same for tabular QA. The finding is stable across three years and several labs: reasoning over structured data goes better through structured intermediate representations than through natural language, and this is true of the strongest models available.
Third, function calling has beaten natural-language tool use everywhere it has been measured. BFCL, ToolBench and tau-bench agree, and every frontier lab has converged on structured tool calls as the production path. The industry ran this experiment at scale and the results weren’t close. An LLM constructing a typed object is a better client than an LLM writing sentences about what it intends to do.
One counterweight belongs in the record. CompoST shows text2SPARQL F1 still below 0.57 on compositional splits with the full schema in context. Structured targets are easier than unstructured ones; they are not solved.
But this point counts for our refusal rather than against it. If models translating into a grammar with the schema present still fail half the time compositionally, handing them a translation monopoly at the protocol boundary is not a design but a bet placed on someone else’s benchmark cycle.
What WunderOS does instead
The WunderOS platform exposes structured Wunderlog, our variant of Datalog for agents, over WebSocket as the primary read and write surface. There is no NL-to-Wunderlog layer in core. Agents construct queries and writes directly by three routes:
- function calling against the schema,
- grammar-constrained decoding to the Wunderlog grammar, and
- ordinary programmatic construction in SDK code.
In each case the schema is the tool schema; the predicate vocabulary ships to the agent as a typed description of what can be said, which is exactly what a function-calling runtime already knows how to handle.
Two real consequences follow from all this.
First. A significant hallucination class disappears instead of shrinking. A translation layer can mis-name a predicate or invent a relation, so the substrate needs machinery to catch it after the fact. Remove the translator and there is nothing to catch. The failure mode has no habitat. Validation reduces to conformance against the grammar, which is deterministic and cheap.
Second. Predicate drift is handled fail-open instead of fail-closed. Names change; that is what names do. A translation layer turns drift into hard failure, because it committed to an interpretation at write or query time and the interpretation was wrong. WunderOS defers interpretation to retrieval, where vector-symbolic fuzzy match over the predicate space absorbs drift gracefully. Nothing in the hot path decides whether a changed name means what the speaker meant; the retrieval layer returns the near neighbors and the caller judges.
Fail-open beats fail-closed here because the cost of a loose match is a ranked list the agent can inspect, while the cost of a failed translation is a dead turn.
All of WunderOS eats this dog food
Our no-NLP claim extends past the wire format. Hot path means the whole synchronous path an agent’s turn travels: parse, plan, read, write, respond.
No component in that path performs natural-language processing. Extraction from raw text happens, because memory arrives messy, but it happens at ingest, off the path, where its latency and error rates tax no agent or person who’s waiting.
Re-ranking, summarization, and any other learned transformation live in the same place. What executes while an agent holds a turn open is deterministic: a protocol parser, an evaluator, storage. Its latency is measurable once and true thereafter.
That determinism is not only an aesthetic preference; it’s also contractual in a way we think matters for regulated enterprises. WunderOS promises replayable runs, and a run containing an arbitrary frontier call mid-path cannot be replayed honestly, because the second pass consults a different model state than the first.
Deterministic hot paths are what make the replay guarantee a property of the system rather than an aspiration in the docs. The token tax points the same direction. Every translation layer bills per turn forever, which puts a floor under inference COGS that no caching scheme removes. Removing the layer removes the floor.
The refusal composes with Model Minimalism
Model Minimalism (PLRN-022) says that WunderOS uses the least costly and least stochastic mechanism that preserves answer quality. That principle licenses models freely where they earn their place, and WunderOS uses them: local SLMs are permitted and expected, the model router exists, and heavy semantic work belongs to models that can do it.
The hot-path invariant is the positional half of the same principle. It asks of each model call not “is this model good?” but “what is this model doing between the agent and the substrate?”
When the answer is translating, the mechanism is wrong, because the thing being translated from is less reliable than the thing being translated into, and the call adds latency and variance to a path whose value is that it has neither.
Let’s put the contrast sharply. A model that reads documents and writes facts into Wunderlog is working for the agent, off-path, at ingest speed, and its errors land in a reviewable queue. A model that takes an agent’s request and produces a query is standing in the doorway, charging rent on every turn, and its errors land in production.
The first is Model Minimalism at work. The second is what this PLRN refuses publicly and what WunderOS refuses in implementation.
The costs of our principle
We can admit the costs bluntly.
First. Cold-start friction is real: developers who expect to type a question into a box will find a schema instead, and the SDK examples have to show structured construction early enough that the shape of the interface is legible in the first few minutes.
Second. The demo narrative gives up the cheap shot—asking ChatGPT about your data in front of investors—and replaces it with something slower to land and harder to argue with: a function-calling agent constructing typed queries against a live substrate, deterministically, at zero marginal inference cost. That’s the bowtie earning its keep: the point in enterprise AI where authorized action creates business value for users and equity value for our partners.
Third. Authoring-time affordances, predicate discovery, and schema review for humans, remain desirable and remain out of scope for core; they are separate concerns with separate designs, and listing them here is how the translation layer stays out by the back door.
Against those actual costs stands a single fact about the alternative:
Every agent platform that puts NLP in the hot path has accepted a nondeterministic, metered, failure-prone intermediary as a permanent tenant of its most valuable real estate and has done so for a UX benefit that agents, the actual residents of the platform, do not want and cannot use.
WunderOS declines that tenant. Our house is not for sale.
References
Sequeda, J., Allemang, D., & Jacob, B. (2023). A Benchmark to Understand the Role of Knowledge Graphs on Large Language Model’s Accuracy for Question Answering on Enterprise SQL Databases. arXiv:2311.07509.
Allemang, D., & Sequeda, J. (2024). Increasing the LLM Accuracy for Question Answering: Ontologies to the Rescue! arXiv:2405.11706.
Schmidt, D. M., Schubert, R., & Cimiano, P. (2025). CompoST: A Benchmark for Analyzing the Ability of LLMs To Compositionally Interpret Questions in a QALD Setting. arXiv:2507.21257.
Gao, L., et al. (2022). PAL: Program-aided Language Models.
Chen, W., et al. (2022). Program of Thoughts Prompting.
Wang, Z., et al. (2024). Chain-of-Table: Evolving Tables in the Reasoning Chain for Table Understanding. ICLR.
Tam, Z. R., et al. (2024). Let Me Speak Freely? A Study on the Impact of Format Restrictions on Performance of Large Language Models. EMNLP.
A note on method
Written in conversation with the mysterious Ox Alpha as structured interlocutor and prose editor. The architectural commitments, the evidence base, and the claims are mine.
Kendall Clark · k@pentad.ai
—Great Falls, Virginia
August 2026