Your AI Agents Are Paying for Missing Context

Horizon Context is now in public preview. Here’s what it costs (as far as the docs say), and how tags, lineage and ownership turn it into a cost tool

Picture a finance team with seven tables that have revenue in the name. Three are sandbox copies, two are staging, and only one feeds the monthly close. That’s not my example. It’s straight from Snowflake’s Horizon Context documentation, which adds the punchline: “New analysts pick the wrong one, and so do AI agents.”

On October 20, Snowflake announced that the core pieces of Horizon Context are in public preview: metadata connectors for 18 sources, a targeted privilege for stewards to edit descriptions, and automatic propagation of descriptions to downstream columns. Snowflake frames it as a governed context layer for people, BI tools and AI agents.

Most coverage will focus on answer quality. I want to look at the bill, because missing or duplicated context costs money in ways that rarely show up as a line item.

Where missing context shows up on your bill

When an agent or analyst doesn’t know which table is authoritative, a few expensive things happen:

• Wrong-table queries. An agent that picks the sandbox copy still burns warehouse time. Then someone notices the number is off, and the query runs again against the right table. You pay twice for one answer.
• Context rebuilt per app. Snowflake’s announcement puts it plainly: “maintaining a separate set of instructions and definitions for each agent creates more work and more opportunities for inconsistency.” Every app that redefines “active customer” in its own prompt is paying engineers to repeat work, and paying tokens to send that definition with every call.
• Zombie tables nobody dares to drop. If nobody knows who owns a table or what depends on it, it stays. It keeps its storage, and often the pipeline that refreshes it.
• AI-generated documentation, repeatedly. Cortex can write descriptions for you, but that isn’t free (more on that below). Generating descriptions for the same column in five downstream views is waste.

What’s new is that agents query far more often than people do, so guessing gets expensive.

Seven revenue tables, one certified. Agents pay for guessing wrong.

What Horizon Context itself costs

I checked Snowflake’s documentation and the Service Consumption Table (effective November 4, 2026). Snowflake says there’s no charge for adding metadata connectors, for ingesting metadata from them, or for storing the metadata, lineage and popularity data they collect, and the consumption table has no line item for them. The connectors page lists them as a preview feature “available to all accounts.” Two costs still apply: some steps, such as the privilege check when you create a connection, run on your active warehouse at standard rates, and the provider of the source system bills for the compute that the metadata queries use. Preview terms can change, so check again before you budget.

What is documented is the cost of the pieces around it:

• Auto-generated descriptions use Cortex. According to Snowflake’s docs, generating descriptions consumes warehouse credits plus Cortex charges for smaller models, which appear on the bill as AI Services. Cortex AI function usage is recorded in CORTEX_AI_FUNCTIONS_USAGE_HISTORY, though Snowflake’s docs don’t say whether description generation appears there.
• Description propagation is part of the public preview. I found no separate charge documented for it.
• Access History, which you need to see who actually queries what, requires Enterprise Edition or higher.

Propagation is the quiet cost saver. It uses as-is column lineage to copy a description downstream. According to Snowflake, it stops when values are transformed, combined or aggregated, and doesn’t overwrite descriptions written directly on downstream columns. Describe a customer ID once at the source, and every pass-through view inherits it, with no AI call needed.

Tags: one vocabulary for trust and cost

On October 20, Snowflake also made Snowflake-provided tags generally available. These are ready-made tags in the SNOWFLAKE.TAGS schema of every account, and two of them matter here:

• SNOWFLAKE.TAGS.COST_CENTER, for cost tracking and budget control.
• SNOWFLAKE.TAGS.CERTIFICATION_STATUS, with fixed values such as CERTIFIED and DEPRECATED. Administrators can’t change those values, so every account and every AI workflow reads them the same way.

That second tag is a trust signal and a cleanup list. If a table is DEPRECATED, every query against it is either a mistake or a dependency you haven’t migrated yet. Here’s how to find them:

WITH deprecated AS (
  SELECT object_database || '.' || object_schema || '.' || object_name AS fqn
  FROM snowflake.account_usage.tag_references
  WHERE tag_database = 'SNOWFLAKE' AND tag_schema = 'TAGS'
    AND tag_name = 'CERTIFICATION_STATUS' AND tag_value = 'DEPRECATED'
)
SELECT d.fqn, ah.user_name, COUNT(DISTINCT ah.query_id) AS queries
FROM snowflake.account_usage.access_history ah,
  LATERAL FLATTEN(input => ah.base_objects_accessed) obj,
  deprecated d
WHERE obj.value:"objectName"::STRING = d.fqn
  AND ah.query_start_time >= DATEADD('day', -30, CURRENT_TIMESTAMP())
GROUP BY 1, 2
ORDER BY queries DESC;

If a service user for an agent shows up here, you’ve found both a cost problem and a correctness problem. If nothing shows up for 30 days, you have a strong candidate for retirement.

Lineage shows the branch nobody has queried in 30 days

Lineage turns cleanup from scary into routine

Most teams don’t drop unused tables because they can’t see what depends on them. That’s the problem lineage solves. Horizon Context stitches lineage from Snowflake query history, external query logs, BI tools and OpenLineage feeds into one column-level graph. With connectors for tools like dbt and Tableau, you can follow a column from the source database all the way to the dashboard that displays it.

The Snowflake docs walk through the impact-analysis version: an engineer asks the built-in coding assistant what breaks if they change a table. It reports the downstream objects, how often each is queried and how many users it affects. Flip that around and you get a cost question: which expensive pipelines feed dashboards nobody opens?

One thing worth knowing: the connectors read metadata, not data. Snowflake says they “do not require replicating the underlying data sets into Snowflake,” and nothing is connected until you create a connection.

Make spend traceable to owners

Context only helps with cost if spend maps back to the people who can act on it. Snowflake’s cost attribution guide recommends object tags for resources and users, plus query tags for apps that run queries on behalf of several teams. That covers AI agents. This is the guide’s query for compute by query tag, trimmed to the compute column, which also shows how much is untagged:

SELECT COALESCE(NULLIF(query_tag, ''), 'untagged') AS tag,
       SUM(credits_attributed_compute) AS compute_credits
FROM snowflake.account_usage.query_attribution_history
WHERE start_time >= DATEADD(MONTH, -1, CURRENT_DATE)
GROUP BY tag
ORDER BY compute_credits DESC;

One caveat from the docs: QUERY_ATTRIBUTION_HISTORY covers warehouse compute only. It excludes idle time, storage, serverless features and AI token costs. Report token costs from the Cortex usage views next to it.

Untagged spend is usually the biggest line

A practical starting checklist:

1. Tag the authoritative version of your top 20 most-queried tables CERTIFIED, and mark the known copies DEPRECATED.
2. Write descriptions on source columns and let propagation cover pass-through views before you pay for AI-generated ones.
3. Give every agent and app its own service user and query tag.
4. Run the deprecated-access query monthly and treat each hit as a ticket.

Where Seemore fits in

At Seemore, we connect lineage and real usage to cost, so you can see which pipelines, tables and dashboards drive spend, and which have no downstream consumers at all. A shared context layer like Horizon Context makes that picture richer. The work still comes down to the same thing: knowing who owns each asset, and whether anyone still needs it.