We're seeing a wave of newer LLMs with far more reasoning power, and that reasoning can burn through a lot of tokens. That worries enterprises trying to onboard these AI tools quickly, because the token cost is hard to predict.

Natural Language Querying

One fast-emerging use case is querying databases in natural language. Databases have always been expert systems, reachable by only a handful of people in an organization. LLMs change that: they read a user's intent and interpret complex database schemas far better than before, opening up the databases and enterprise data to business users. This is exciting, but token cost is a growing concern. Enterprise databases can be massive, and far more business users are eager to ask for data in natural language.

In this post, we look at what token cost means when you make databases queryable in natural language. These systems go by a few names — AI/BI, Gen BI, or simply Data Agents; we'll use AI/BI throughout. At a high level, they all share an AI component that translates a natural language query into backend SQL and then runs it against the underlying database.

Database-specific AI/BI

We look at two category leaders, Snowflake Cortex Analyst and Databricks Genie, both of which embed natural language querying deeply inside their database platform. Snowflake prices Cortex Analyst at roughly 6.7 credits per 100 messages, or about 0.067 credits per query. A credit runs $2.00 to $4.00 depending on the edition, so a single natural language query costs between $0.13 and $0.27; we'll use the cheapest end, $0.13, throughout this analysis. Databricks Genie works out cheaper: at an estimated 150 DBU for 80–100 questions per month, or about 1.5 DBU per query, and a floor rate of $0.07 per DBU, each query comes to $0.105 — which we round to $0.10.

Database-agnostic AI/BI

Instead of embedding AI/BI inside the database, there's another option: compile the natural language query externally. That's Tursio's approach. It infers a context graph from the underlying database, enriches it with business rules and semantics, and compiles user questions against that graph. Because the compilation happens outside the database, Tursio isn't tied to any one of them — it works with any SQL (and NoSQL) database. It also uses a mix of cheaper models for the small, well-defined steps in the compilation, so it doesn't lean on complex reasoning, and it bills everything straight to your LLM provider on your own keys. Think of it as a bare-metal approach to compiling natural language into database queries. So what does that do to token cost?

The table below breaks down the bare token costs of the Tursio approach in detail.



All averages in the above estimator are computed from reference workloads; they depend mainly on how the Tursio platform handles prompts, and we keep on updating them as the platform evolves. The estimated usage comes from reference customer deployments (20–25 users, 50–200 queries/user/month) and is an input parameter — these can be adjusted to reflect the expected workload. The dollar costs reflect current publicly available LLM pricing, but the actual bill depends on the LLM or Azure Foundry subscription including credits. Models are chosen for their cost and reliability on data tasks, and Tursio continuously evaluates and upgrades to newer models with no change in the user experience. As a rule of thumb, one token is roughly 4 characters, or 0.75 of a word.

Comparing Costs

The figure below compares Tursio's token cost with Snowflake and Databricks as the number of queries grows from 1K to 1M per month. Billed directly against your own LLM subscription, Tursio's bare LLM cost is far lower — more than 3× below Databricks and more than 4× below Snowflake.



Clearly, there is a significant difference in cost, and enterprises could easily end up spending hundreds of thousands of dollars in token costs. Note that this is purely the LLM token costs and does not include the underlying data platform costs. AI/BI, therefore, is becoming a big spend category and something that enterprises need to plan well.

One obvious question is whether those cost savings come at the expense of accuracy. But accuracy depends on how good the context we give the LLMs is — and for most organizations, that context lives in people's heads. Structuring that context, making it unambiguous, and tuning it continuously over time is what matters most. That's a topic for another post.

Observations

• There's little benefit to building AI/BI tied to a database platform when a system that scales independently can be far cheaper.
• The cost also stays consistent across every database, instead of varying by platform — 10¢ per query on Databricks versus 13¢ on Snowflake.
• There's an argument for leveraging the proprietary metadata stores, but those stores are increasingly either embracing all data (e.g., OneLake) or moving to open formats (e.g., Apache Ossie). So, again, there's no point in locking the AI/BI system inside a database.
• Fundamentally, data and AI scale in completely different ways. Data is compute-intensive, so its cost depends heavily on how the backend infrastructure is engineered. AI is context-intensive, and the inferencing itself is already commoditized externally.
• There's no point in “reselling” tokens. Most current solutions wrap LLMs in value-added services and mark up the cost — and they're not the only ones; PromptQL, for example, prices natural language queries at $0.14–$0.28 each. The markup makes sense from a provider's point of view, but the alternative is to run bare-metal LLMs entirely within the enterprise's own governance.
• Accuracy isn't inherently locked inside the database platform either. It rests on metadata that's being opened up, business semantics that are moving to open formats, and organizational knowledge that lives in people's heads anyway.

Conclusion

So what does this mean for databases as a field? AI is burying the database under one more layer of abstraction — one where natural language is the interface and agents are the new consumers. That's scary and exciting at the same time. Most likely, we'll watch the databases we know evolve into something far more aligned with AI agents and systems, and further removed from the end user.