Data Intelligence Agent

Deterministic Answer Flow

A DAF for every question. That's the whole game.

For every question you ask, the agent generates a Deterministic Answer Flow — a structured, reproducible plan that produces the same answer every single time the same question is asked. DAF is what separates AirQuery from every other LLM-on-data tool on the market.

Question

"Why did APAC revenue drop last quarter?"

→

Deterministic Answer Flow

Bounded context Constrained reasoning Compiled plan HI-signed metrics Calibrated confidence Audit trail

→

Deterministic Answer

22% drop driven by 3 enterprise churns in Singapore totalling $840k ARR.

↻ Same question runs the same DAF and produces the same answer — every single time.

The six techniques inside every DAF

Each one closes a different door to drift.

Bounded context

Only the relevant slice of the Thinkmap is loaded for each question — not the entire schema. Same question, same context, same reasoning.

Constrained reasoning

The agent traverses verified Thinkmap nodes; it doesn't free-form invent table names or metrics. No degrees of freedom = no drift.

Compiled plans

Questions resolve to structured plans (not loose code). Plans are deterministic, replayable, and diff-able across runs.

HI-signed metrics

Every metric used must be a verified entry in the semantic layer. If MRR means SUM(active.amount) today, it means that tomorrow too.

Calibrated confidence

Every DAF emits a confidence score derived from coverage, verification, and historical accuracy — not from the model's self-assessment.

Replayable audit trail

Every DAF is stored verbatim. Re-run it next month, get the same answer. Show it to a regulator. Diff it against a colleague's run.

Most "AI for data" tools rely on the LLM to be deterministic, which it never is. AirQuery's agent uses the LLM inside a deterministic flow — the model proposes, the DAF verifies. The result is reproducibility you can bet a quarterly report on.

Dynamic context surfacing

It reads the question then fetches what it needs.

Most "AI for data" tools push your entire schema into the prompt and pray. That's slow, expensive, and full of noise. The AirQuery agent does the opposite — it identifies the handful of entities, metrics, and rules in your Thinkmap that the question actually depends on, then loads just those. Smaller context. Sharper reasoning. Lower bill.

⚠ Naive approach

Stuff the whole schema, metric catalog, and sample rows into the prompt. Let the LLM figure it out.

fact_sales(order_id, customer_id, product_id, ship_mode_id, order_date_id, sales, quantity, discount, profit) fact_returns(return_id, order_id, return_reason, refund_amount) dim_customer(customer_id, customer_name, segment_id, region_id, city, state, zip, signup_date) dim_product(product_id, product_name, sub_category_id, category_id, list_price, cost_basis) dim_date(date_id, date, day_of_week, quarter, fiscal_year) dim_segment(segment_id, segment_name)

50k+

tokens

$$$

cost

~70%

accuracy

✓ AirQuery DAF

Surface only the Thinkmap subgraph the question actually depends on. Nothing more.

metric: revenue

entity: Order

dim: dim_region (APAC)

table: fact_sales

rule: exclude returns

ontology: Q2 quarter window

~2k

tokens

$

cost

99%

accuracy

The DAF, step by step

Six stages. One deterministic flow.

Every Deterministic Answer Flow runs through the same six stages. Every stage is visible, traceable, and reproducible — no black box. Re-run the DAF, get the identical result.

01 PARSE

Read the question

Identify entities, metrics, time windows, comparisons referenced in natural language.

02 LOCATE

Find context

Walk the Thinkmap to find the relevant subgraph: data tables, metric definitions, ontology rules.

03 PLAN

Build a strategy

Decompose into a step-by-step plan. Pick the cheapest path. Check assumptions early.

04 EXECUTE

Run the plan

Compile to SQL, dispatch against the warehouse, stream results back. Catch errors as they happen.

05 VERIFY

Sanity check

Compare results against the Thinkmap's expectations. Flag anomalies. Score confidence.

06 ANSWER

Reply with sources

Natural-language answer + cited metrics + SQL trace + Thinkmap subgraph used.

Why "runtime" matters

No staleness. Ever.

The agent isn't a model that was trained on your data three months ago. It reasons fresh on every question against the current state of your Thinkmap and warehouse. Every change propagates instantly. Here's a real Tuesday at a customer:

09:14 · FINANCE

Finance lead updates revenue definition in the semantic layer to exclude refunded line items. Commit pushed.

09:14 + 0s

New definition is live in the Thinkmap. no rebuild

09:21 · SLACK

Sales VP asks @airquery "Revenue this quarter?" The agent uses the new definition immediately. No retrain. No reindex. No wait.

11:02 · DATA TEAM

Adds a new fact_subscriptions table to the warehouse. Maps it into the Thinkmap with three clicks.

11:02 + 0s

Next question that touches subscriptions automatically picks up the new table. live

Put a real analyst on every conversation.

The AirQuery Data Intelligence Agent is what powers Thinkbox-driven answers in the Wise App, Slack, Teams, and your custom embeds.

Get Started Free See Thinkbox

Your runtime AI analyst.