An AI Navigator is a system for turning a broad question into a narrow, governed, reproducible computational path. It is not merely search, not merely RAG, and not merely an agent framework. It is a control system for context.
The basic problem is easy to state. A person asks:
Which communities face overlapping fiscal capacity, energy burden, mobility disruption, and climate-health risk?
A Big AI system is tempted to gather everything that might be relevant: finance documents, energy surveys, mobility tables, climate reports, health studies, prior briefings, policy files, and maybe a few thousand embeddings. That creates a huge context-selection problem. The model must infer meanings, ignore irrelevant fields, respect permissions, remember provenance, avoid forbidden data, and explain its answer after the fact. Some of that work may happen inside a GPU-bound model call where the organization has the least control and the least reproducibility.
Querygraph reverses the order. It does not begin with a model. It begins with the route:
The model becomes one component in a governed path, not the place where every hard problem is dumped.
Big AI is powerful, but its default architecture is poorly matched to many enterprise and scientific tasks. It rewards centralization, massive context, remote inference, opaque optimization, and constant recomputation. Those features are useful for some problems. They are costly and risky for governed knowledge work.
Querygraph proposes a different stack:
| Big AI default | Querygraph alternative |
|---|---|
| Send large context to a large model. | Build a small, permitted semantic context first. |
| Treat retrieval as approximate chunks. | Resolve ontology terms, variables, fields, and policies. |
| Recompute context for each question. | Cache dataset metadata, graph routes, and lineage. |
| Centralize inference around GPU services. | Keep data local and use CPU-friendly SQL/graph work first. |
| Govern after the model responds. | Govern before retrieval and before prompting. |
| Trust logs after the fact. | Sign requests, responses, denials, and lineage roots. |
| Accept model drift as inevitable. | Record versions, prompts, payload hashes, and data state. |
The point is not to pretend that small models always beat large models. The point is to stop using large models as a substitute for data infrastructure. When the semantic route is precise, the model has less to guess. When the context is focused, inference is cheaper. When the policy is checked before retrieval, safety is structural rather than rhetorical. When lineage is stored in the lakehouse, reproducibility becomes part of the data platform.
In Querygraph, context is not a bag of text. A focused context is a structured artifact with:
That artifact can be cached, hashed, signed, replayed, compared, and audited. This is why Querygraph can be stable in a way that prompt-only systems are not. The expensive part of understanding the domain does not have to be regenerated inside a model context every time.
The CPU-friendly parts of the system are not second-class. They are the foundation. Parsing a Dataverse file, inferring column types, writing Parquet, loading a Sail table, traversing a Grust graph, evaluating an ODRL permission, computing a hash, and generating an OpenLineage event are all deterministic or nearly deterministic operations. They can be tested. They can run locally. They can be repeated.
GPU-bound inference is reserved for the part that genuinely needs generation: summarizing a small body of permitted evidence, translating a user question into a candidate ontology term, or drafting a narrative from signed summaries. Even then, the model call is wrapped by TypeDID, bounded by ODRL, and recorded by OpenLineage.
That is the practical alternative to Big AI: use conventional computing for what conventional computing does well, and use models only after the problem has been made small enough to govern.