Snowflake Horizon Context: The Governed Context Layer for AI, BI and Apps

The thoughts and opinions expressed in this article are purely my own and do not represent the views, intentions, or positions of my employer. All ideas are personal and independent.

Code: github.com/domfp13/snowflake-se/horizon-catalog/horizon-context/setup

The Problem: Same Data, Different Answers

Your head of sales sees $14.2 million in Q3 revenue. Your CFO sees $12.8 million. Both asked an AI agent the same question this morning. Same data. Why the discrepancy?

This happens when business logic is scattered across separate tools: a metric defined inside a BI model only one team owns, a calculation buried in a dashboard, a set of instructions manually hardcoded into an LLM prompt. The result is not just metric drift — it is a trust gap that makes it hard to move AI projects forward with confidence.

Snowflake Horizon Context solves this by providing a connected, governed semantic foundation with active context for AI and BI.

What is Horizon Context?

Announced at Snowflake Summit 2026, Horizon Context is a new capability within Snowflake Horizon Catalog that transforms raw metadata into governed business meaning. It builds on Horizon Catalog’s metadata foundation by:

• Collecting context from across your data estate (inside and outside Snowflake)
• Enriching it with business definitions, relationships and quality signals
• Activating it so AI agents, BI tools and applications can automatically discover and apply trusted logic

The key differentiator: because Horizon Context is native to the Snowflake engine, governance is enforced at the meaning level, not just the table level. Role-based access control and masking policies follow the context — every tool, every query, every AI response.

Architecture: Collect, Enrich, Activate

1. Collect: Build the Complete Picture

AI needs context from your entire data estate, not just what lives in Snowflake. Horizon Context extracts metadata from external systems and collects it in Horizon Catalog.

Metadata Connectors Connect to PostgreSQL, SQL Server, Tableau, Power BI, dbt and more. Collect schemas, query logs, dashboard definitions. Private Preview OpenLineage API Configure OpenLineage producers (Apache Airflow, dbt, custom scripts) to send lineage events to Horizon Catalog.Public Preview Open Semantic Interchange (OSI) An open standard for exchanging semantic metadata between disparate systems. 54+ participating vendors.Specification Published

2. Enrich: Turn Raw Metadata into Business Meaning

Raw context needs enrichment to create higher levels of meaning. Horizon Context automates much of this while keeping humans in the loop.

Column-level lineage Mines lineage from Snowflake and external query logs, BI systems and OpenLineage feeds, then stitches it into a complete graph.

Popularity signals Uses query and access logs to calculate which data assets are most used — a signal for authoritativeness when dozens of similar-looking assets exist.

AI-generated documentation Uses AI to generate table and column descriptions from metadata and (optionally) sample data. Semantic Views Define business logic (metrics, dimensions, facts, relationships) once. Enhanced at Summit 2026 with LOD calculations, composable definitions and automatic query rewrite. Semantic Studio A full AI-assisted IDE in Workspaces with CoCo integration and Git-based versioning for building and testing semantic views.Semantic View Autopilot Ingests existing SQL, Tableau workbooks (.twb/.twbx) or Power BI files (.pbit/.pbix) and generates semantic views automatically.

3. Activate: Make Context Work Automatically

Context only matters if it gets used. Horizon Context makes your definitions discoverable, accessible and automatically activated.

Context Search (Universal Search) Hybrid keyword + semantic search across your entire data estate. Uses popularity for ranking and access control for filtering. Automatic semantic view discovery CoCo automatically searches for and queries relevant semantic views when asked a data question. Falls back to tables if none exist.BI interoperabilityQuery governed definitions natively from Power BI, Tableau, Excel, Google Sheets, Looker, ThoughtSpot, Sigma, Hex and Omni. MCP for external agents Expose semantic views via Model Context Protocol (MCP), governed by Horizon Catalog. Connect from Claude, Cursor, or any agent framework.

Why This Matters for the Agentic Era

Autonomous agents cannot reason about your business if your data carries no embedded meaning:

• Without context, an agent guesses.
• With context, an agent acts.
• With governed context, an agent can be trusted.

A context layer bolted on top of a governance engine must reconcile two systems every time a query runs. When definitions drift, the agent follows the wrong one. Horizon Context is different because semantics live inside the governance engine and are enforced at query time — not copied or cached.

Ecosystem Partners

Horizon Context integrates with the tools enterprises already use:

Tableau Semantic view definitions reflected in Tableau data models for consistent metric aggregation Power BI Native support for querying Snowflake semantic views (private preview) Looker (Google Cloud) Universal semantic layer extended to support in-database models with Snowflake Semantic Views ThoughtSpot Native support for querying semantic views enriched with AI-native context Sigma Computing Queries semantic views in real time; governed definitions reflected in every spreadsheet and dashboard Hex Trusted, governed metrics available in notebooks, SQL and data apps Omni Governed definitions surfaced in AI-driven chat, spreadsheets and dashboards Alation Governed semantic definitions connected to enterprise data catalogs Collibra Bidirectional trusted metadata flow for a single view of enterprise context AtScale Business definitions governed once and used everywhere analysts and AI work

Implementing Horizon Context: A Practical Example

The demo pipeline in this repository demonstrates the Horizon Context pattern end-to-end:

PostgreSQL (pg_lake)
    │
    ├── customers_iceberg
    ├── products_iceberg
    ├── orders_iceberg
    └── order_items_iceberg
            │
            ▼  [Collect: OpenLineage API registers upstream lineage]
    ┌───────────────────────────────────────────────────┐
    │  Snowflake Horizon Catalog                        │
    │                                                   │
    │  RAW Layer (Iceberg Tables via Catalog Integration)│
    │       │                                           │
    │       ▼                                           │
    │  TRANSFORM Layer (Dynamic Tables)                 │
    │       │                                           │
    │       ▼  [Enrich: Semantic View with metrics,     │
    │  ANALYTICS Layer (View)    dimensions, synonyms]  │
    │       │                                           │
    │       ▼                                           │
    │  Semantic View + Cortex Agent                     │
    │       │  [Activate: Agent auto-discovers and      │
    │       │   queries governed definitions]           │
    │       ▼                                           │
    │  Power BI Report / Streamlit Dashboard            │
    │       [Activate: downstream lineage registered]   │
    └───────────────────────────────────────────────────┘

How Each Step Maps to Horizon Context

Step File Horizon Context Pillar Postgres Iceberg tablessetup/02_pipeline_postgres.sql

Source data (external database) Catalog integrationsetup/01_test_presetup.sql

Collect - Connect external databasePipeline (RAW/TRANSFORM/ANALYTICS)setup/03_pipeline_snowflake.sql

Data engineering foundationSemantic View + Agentsetup/04_semantic_view_and_agent.sql

Enrich - Business definitions, metrics, synonyms, AI instructionsExternal lineage (OpenLineage API)setup/05_register_lineage.sh

Collect - Register upstream/downstream lineageStreamlit Dashboardsetup/06_streamlit_app.py

Activate - Governed context surfaced in an app

What We Built

Collect — We connected a Snowflake Postgres instance (PG_SNOWFLAKE_PROD) running pg_lake with managed Iceberg tables. A catalog integration (CATALOG_SOURCE = SNOWFLAKE_POSTGRES) exposes those Iceberg tables directly in Snowflake without data movement. We then used the OpenLineage REST API to register external lineage events so the Snowsight lineage graph shows:

• Upstream: PostgreSQL tables (with the Postgres icon) feeding into HRZN_DB.RAW.*
• Downstream: V_ORDER_ANALYTICS feeding a Power BI report (with the Power BI icon)

Key discovery: Use the postgresql:// namespace (not postgres://) with "sourceType": {"sourceType": "POSTGRESQL"} facets to render the Postgres icon. Use "datasetType": {"datasetType": "REPORT"} facets for downstream BI output nodes.

Enrich — We created a semantic view (HRZN_DB.ANALYTICS.ORDER_ANALYTICS_SEMANTIC_VIEW) with:

• 10 facts (quantity, prices, margins, customer lifetime metrics)
• 11 dimensions (dates, status, customer/product attributes with synonyms)
• 6 metrics (total revenue, gross margin, units sold, order count, AOV, margin %)
• AI instructions (AI_SQL_GENERATION for safe division, rounding; AI_QUESTION_CATEGORIZATION to reject out-of-scope questions)

This is the governed business logic layer — define “revenue” and “margin” once, and every downstream tool (agent, dashboard, BI tool) gets the same answer.

Activate — We created a Cortex Agent (ORDER_ANALYTICS_AGENT) with JSON specification that uses cortex_analyst_text_to_sql to automatically query the semantic view. The agent does not need to know table schemas or SQL -- it discovers governed definitions from the semantic view and generates correct queries. We also deployed a Streamlit-in-Snowflake dashboard that queries the same view, demonstrating governed context activated in two different consumption patterns simultaneously.

The Resulting Lineage Graph

The complete lineage visible in Snowsight:

┌─────────────┐     ┌─────────────┐     ┌─────────────────┐     ┌───────────────┐
│ PostgreSQL  │     │  HRZN_DB    │     │  HRZN_DB        │     │  HRZN_DB      │
│ (pg_lake)   │────>│  RAW        │────>│  TRANSFORM      │────>│  ANALYTICS    │
│             │     │             │     │                 │     │               │
│ customers   │     │ CUSTOMERS_  │     │ DT_ORDER_       │     │ V_ORDER_      │──┐
│ products    │     │ ICEBERG     │     │ DETAILS         │     │ ANALYTICS     │  │
│ orders      │     │ PRODUCTS_   │     │                 │     │               │  │
│ order_items │     │ ICEBERG     │     │ DT_CUSTOMER_    │     └───────────────┘  │
└─────────────┘     │ ORDERS_     │     │ SUMMARY         │                        │
                    │ ICEBERG     │     └─────────────────┘         ┌──────────────┼──────────────┐
                    │ ORDER_ITEMS │                                  │              │              │
                    │ _ICEBERG    │                                  ▼              ▼              ▼
                    └─────────────┘                            Power BI      Streamlit      Cortex Agent
                                                              Report        Dashboard      (Snowflake
                                                                                           Intelligence)

Key Takeaways

1. Define once, use everywhere. Semantic Views are the governed foundation — metrics, dimensions and business logic defined in one place and consumed by every tool.
2. Context must be active, not passive. It is not enough to store metadata. Horizon Context activates it so agents and tools discover and apply definitions automatically.
3. Governance at the meaning level. Unlike bolt-on semantic layers, Horizon Context enforces RBAC and masking at the semantic layer — a definition restricted for finance stays restricted in Power BI, Salesforce and any agent.
4. Open ecosystem. OpenLineage for lineage ingestion, OSI for semantic interchange, MCP for agent access, and native connectors for BI tools.
5. Built for agents. As AI agents move from experimentation to production, they need governed context to produce trusted answers. Horizon Context is designed for this agentic era.

Deep Dive: Open Semantic Interchange (OSI)

One of the most significant components of the Collect pillar is the Open Semantic Interchange (OSI) specification. Understanding what it actually is — technically — clarifies why it matters for Horizon Context.

The Problem OSI Solves

Every tool in your stack defines “Revenue” differently:

• Snowflake Semantic View: SUM(unit_price * quantity)
• dbt metric YAML: measure: revenue, type: sum, sql: amount
• Tableau calculated field: SUM([Amount])
• Sigma metric: custom aggregation in the workbook
• Power BI DAX measure: Revenue = SUMX(Orders, Orders[UnitPrice] * Orders[Qty])

They all mean the same thing but are expressed in incompatible, proprietary formats. You cannot take your semantic model from one tool and use it in another without re-authoring.

What OSI Actually Is

OSI is a YAML/JSON file format — nothing more, nothing less. It is a portable document that describes:

• Datasets — which physical tables, their primary keys
• Fields — dimensions and measures, with the SQL expression in each dialect
• Relationships — how datasets join (foreign keys)
• Metrics — aggregate expressions like SUM(orders.amount)
• AI context — synonyms, instructions for LLMs

The key technical insight is the **dialects array** on expressions:

metrics:
  - name: total_revenue
    expression:
      dialects:
        - dialect: ANSI_SQL
          expression: SUM(orders.amount)
        - dialect: SNOWFLAKE
          expression: SUM(orders.amount)::NUMBER(38,2)
        - dialect: TABLEAU
          expression: SUM([Amount])

The same metric carries its translation for each platform. A converter reads the OSI file, picks the dialect it understands, and imports the definition natively.

How It Works in Practice

┌─────────────────────────────────────────────────────────┐
│              OSI YAML file (the "interchange")           │
│  semantic_model → datasets → fields → metrics           │
│                 → relationships                          │
│                 → ai_context                             │
│                 → custom_extensions (vendor-specific)    │
└────────────┬──────────────┬──────────────┬──────────────┘
             │              │              │
     converter/dbt   converter/snowflake   converter/gooddata
             │              │              │
         dbt metrics   Snowflake SV DDL   GoodData MAQL

The OSI repository already includes reference converters that can:

• Export a dbt semantic layer → OSI YAML
• Import OSI YAML → Snowflake Semantic View DDL
• Import OSI YAML → GoodData metrics
• (Planned: Salesforce, Polaris, Databricks, Sigma, ThoughtSpot)

What OSI is NOT

• Not a runtime layer — it does not execute queries or serve metrics at query time
• Not a replacement for Snowflake Semantic Views or dbt metrics — it is the bridge between them
• Not a new semantic layer product — it is a file format spec

Think of it as OpenLineage for business definitions: OpenLineage standardizes where data flows; OSI standardizes what data means.

The 54+ Partner Ecosystem

The working group includes: Alation, Atlan, AtScale, BlackRock, Coalesce, Collibra, Cube, Databricks, DataHub, dbt Labs, Domo, Firebolt, Hex, Honeydew, Informatica, Instacart, JetBrains, Lightdash, Mistral AI, Omni, Preset, Qlik, RelationalAI, Salesforce, Select Star, Sigma, Starburst, ThoughtSpot, and more.

How OSI Connects to This Demo

In our pipeline, we created ORDER_ANALYTICS_SEMANTIC_VIEW using Snowflake DDL. As OSI converters mature, you could:

1. Export your Snowflake Semantic View → OSI YAML
2. Import that same OSI YAML into dbt, Tableau, Sigma, or any tool with a converter
3. Guarantee that “TOTAL_REVENUE” means the exact same thing everywhere — without re-authoring

This closes the loop on Horizon Context: governed definitions created once in Snowflake, interchanged to any tool via OSI, and consumed with consistent meaning everywhere.

References

Snowflake Official

• Snowflake Blog: Horizon Context — The Governed Context Layer for AI, BI and Apps (Jun 2, 2026)
• Snowflake Product Page: Horizon Context
• Snowflake Horizon Catalog: Data Governance & Discovery
• Snowflake Press Release: Advances Trusted AI with Horizon Catalog
• Snowflake Press Release: Enterprise Data AI-Ready with Snowflake Postgres (Feb 3, 2026)
• Open Semantic Interchange Specification

Snowflake Documentation

• Semantic Views Overview
• CREATE SEMANTIC VIEW DDL
• External Lineage (OpenLineage API)
• Snowflake Postgres: pg_lake
• Data Lineage in Snowsight

Open Semantic Interchange (OSI)

• OSI GitHub Repository (Apache 2.0)
• OSI Core Specification (spec.md)
• Snowflake Blog: OSI Specification Finalized (Jan 2026)
• dbt Labs: What the OSI Spec Means for Metrics, Semantics, and AI
• Unwind Data: OSI Open Semantic Interchange Guide
• OSI Official Website
• SBI Group: Open Semantic Interchange Overview
• DataHub Joins OSI Working Group (Dec 2025)
• Collibra Backs OSI (Nov 2025)

Third-Party Analysis

• Snowflake Summit 2026: Summary of New Features (Medium / Snowflake Builders Blog)
• Atlan: Snowflake Summit 2026 Announcements and What They Mean
• Atlan: Context Layer for Snowflake — Native + Enterprise Guide 2026
• Atlan: Snowflake Semantic Views — A Complete 2026 Enterprise Guide
• Constellation Research: Snowflake Summit 2026 — Redrawing the Boundary Between Data, Context, and Action
• DataHub: Context Layer for Snowflake