Technical Summary: Never the Number: Structural Abstention for AI Systems Whose Answers Are Consumed as Fact

1. The Problem: Fact-Consumed Systems and the Hallucination Risk

The paper addresses a critical reliability failure in Large Language Model (LLM) text-to-SQL systems deployed in "fact-consumed" environments. In these settings—such as enterprise operational dashboards or tool-using agents—the end consumer (a human manager or an automated agent) cannot inspect the generated query. They receive only the final numerical answer.

The core issue is that when an LLM hallucinates a column, mis-aggregates data, or misinterprets a schema, it produces a "fluent wrong answer" that is indistinguishable from a correct one at the point of use. Unlike scenarios where an analyst can audit the SQL, here the error is invisible. The paper argues that for these systems, accuracy alone is insufficient; the system must possess a mechanism to mark which answers are trustworthy. Current statistical approaches (e.g., calibrated confidence, selective prediction) are deemed insufficient because they still generate a candidate answer before deciding to trust it, leaving the user with a plausible but potentially fabricated number.

2. Methodology: The "Perimeter Invariant" and Structural Abstention

The authors propose an architectural pattern called Structural Abstention, governed by a single Perimeter Invariant:

"A component that can fabricate may influence which question the system answers, never which value the system returns."

This invariant divides the system into two distinct regions:

1. The Generative Shell: Contains the LLM. It handles underspecified input, interprets user intent, phrases replies, and manages dialogue state. Errors here are recoverable (e.g., a clarifying question) and visible to the user.
2. The Deterministic Kernel: Contains no generative components. It matches fully specified questions against a bounded, pre-authored set of "answerable question shapes" (templates) and compiles them into queries via deterministic execution. Errors here are impossible by design because the mapping is fixed and auditable.

The Workflow (The Bounded-Answer Dialogue Loop):

1. Interpreter: Extracts determinate entities from user input; leaves gaps unfilled.
2. Elicitor: If the state is incomplete, the shell asks for missing information.
3. Grounder: A deterministic component checks if the current state matches a valid template. If not, it explicitly fails (refusal) rather than approximating.
4. Confirmation: Before any value is computed, the system presents the user with a natural language restatement of the question they are about to answer. The user must assent.
5. Compiler: A deterministic function maps the confirmed question to a query (e.g., SQL).
6. Renderer: The shell phrases the final result using the known data.

Structural vs. Statistical Abstention:
The paper distinguishes its approach from statistical abstention. Statistical methods generate an answer and then estimate confidence to decide whether to abstain. Structural abstention makes unanswerable requests unrepresentable. If a request cannot be mapped to a valid template, the system has "nothing to say" and declines immediately, requiring no confidence estimate.

3. Key Contributions

1. Architectural Invariant: The definition of the perimeter invariant, which strictly separates generative influence (question shaping) from value computation (answer generation).
2. Structural Abstention: A new design axis where refusal is a structural property of the system's representational capacity, not a statistical decision based on confidence scores.
3. Five-Decision Recipe: A domain-agnostic framework for implementing the pattern, requiring decisions on:
   • The unit of answerability (e.g., templates).
   • The representation of partial requests (e.g., slot frames).
   • The compilation target (e.g., SQL, API calls).
   • The confirmation surface (user-readable restatement).
   • The refusal strategy (disclosure of capabilities).
4. Extension to Agentic Systems: The generalization of the invariant from returned values to executed actions: "A component that can fabricate may influence which action is proposed, never which action is executed."
5. Production Case Study: A two-year deployment of a system named GROUNDER in a retail analytics context, alongside a comparison with two generative alternatives (a fine-tuned text-to-SQL parser and a tool-retrieval agent).

4. Results and Deployment Findings

The paper reports on a production system (GROUNDER) used by sales managers to query retail data.

• Reliability: The system successfully prevented "fluent wrong answers." Errors manifested as visible refusals or clarifying questions, not incorrect numbers.
• Coverage vs. Safety: The system traded coverage for safety. It declined questions outside its template pool rather than guessing.
• Comparison with Alternatives:
  • Fine-tuned Parser: While it achieved broader coverage, it failed to provide a signal distinguishing correct from incorrect outputs. It was deemed unsuitable as a primary path for fact-consumed systems.
  • Tool-Retrieval Agent: This alternative (which uses an LLM to orchestrate tool calls) was eventually adopted as a successor. Crucially, it retained the core properties of the kernel: arithmetic was delegated to the database, and tool-call traces provided a partial audit path. It was preferred over the fine-tuned parser because it maintained the "no model computation of numbers" principle, even though it sacrificed some determinism and increased latency.
• Data Bootstrapping: The deterministic kernel generated the labeled data (question-SQL pairs) required to eventually train the fine-tuned parser, demonstrating that a constrained system can bootstrap a generative successor.

5. Significance and Claims

The paper claims that for systems where answers are consumed as fact without audit, reliability is a structural problem, not just an accuracy problem.

• The "Never the Number" Principle: The most significant contribution is the assertion that a generative model should never compute the final value. The model shapes the question; the database computes the answer.
• Auditability: Because the kernel is a deterministic function, any answer can be reconstructed from the confirmed question alone, without needing logs of the model's internal state.
• Failure Visibility: The pattern converts the failure mode from "silent hallucination" to "visible refusal." The authors argue that a visible refusal is preferable to a fluent error in high-stakes decision-making contexts.
• Modesty: The authors explicitly state that the pattern does not solve the problem of novel, exploratory analysis (where question shapes are not repetitive). It is designed for "recurring, parameterized" questions. They acknowledge that the specific implementation (e.g., the bilingual translation model) is now obsolete, but the invariant remains valid.

The paper concludes that while the specific code is dated, the architectural principle—keeping the generative shell outside the correctness-critical path—remains the only way to ensure trust in fact-consumed AI systems. The "successor" to their system was not a more accurate parser, but a tool-using agent that preserved the separation between question formulation and value computation.