↓ Skip to main content
  1. Articles/

Snowflake Cortex AI -- Governance, Audit & Inference Region Guide

Table of Contents

This guide covers every governance surface of Snowflake Cortex AI: audit logging, inference region controls, RBAC, model-level access, EU data residency, Cortex Analyst fallback behavior, AI observability, REST API audit coverage, and the complete model catalog with hosting infrastructure.


Contents
#

  1. Audit Logging & Usage Views
  2. Inference Region Tracking & Control
  3. RBAC & Access Governance for Cortex AI
  4. Model-Level RBAC
  5. EU-Only Inference: Impact Across Cortex Services
  6. Cortex Analyst: Fallback Model Chain & RBAC Interaction
  7. AI Observability & Tracing
  8. REST API Audit Coverage
  9. Model Catalog: Hosting Infrastructure & Data Sovereignty
  10. Summary Matrix

1. Audit Logging & Usage Views
#

Snowflake provides multiple ACCOUNT_USAGE views that cover every surface area of Cortex AI inference. All views are in the SNOWFLAKE.ACCOUNT_USAGE schema and require the SNOWFLAKE database role or ACCOUNTADMIN/SYSADMIN.

1.1 CORTEX_AISQL_USAGE_HISTORY (Primary – GA Dec 2025)
#

The canonical replacement for the older CORTEX_FUNCTIONS_USAGE_HISTORY and CORTEX_FUNCTIONS_QUERY_USAGE_HISTORY views. Covers all Cortex AI SQL functions invoked in queries.

ColumnTypeDescription
USAGE_TIMETIMESTAMP_LTZHour the query completed (not started)
MODEL_NAMETEXTModel used (e.g., llama3.1-70b, claude-3-5-sonnet)
FUNCTION_NAMETEXTAI function called (e.g., AI_COMPLETE, AI_TRANSLATE)
TOKEN_CREDITSNUMBERCredits billed for this function/model/query combo
TOKENSNUMBERTotal tokens processed
TOKEN_CREDITS_GRANULAROBJECTPer-type breakdown (input/output tokens)
TOKENS_GRANULAROBJECTPer-type token count breakdown
QUERY_IDTEXTQuery ID – join to QUERY_HISTORY for full context
QUERY_TAGTEXTSession QUERY_TAG at invocation time
USER_IDTEXTInternal user identifier
WAREHOUSE_IDTEXTVirtual warehouse used

Coverage starts: November 17, 2025. Data is retained for 365 days.

Example – usage by model and user over 30 days:

SELECT
    DATE_TRUNC('day', h.USAGE_TIME)            AS usage_date,
    u.NAME                                      AS user_name,
    h.FUNCTION_NAME,
    h.MODEL_NAME,
    SUM(h.TOKEN_CREDITS)                        AS total_credits,
    SUM(h.TOKENS)                               AS total_tokens
FROM SNOWFLAKE.ACCOUNT_USAGE.CORTEX_AISQL_USAGE_HISTORY h
JOIN SNOWFLAKE.ACCOUNT_USAGE.USERS u ON h.USER_ID = u.USER_ID
WHERE h.USAGE_TIME >= DATEADD('day', -30, CURRENT_TIMESTAMP())
GROUP BY 1, 2, 3, 4
ORDER BY usage_date DESC, total_credits DESC;

1.2 CORTEX_AI_FUNCTIONS_USAGE_HISTORY (GA Jan 2026)
#

A complementary view introduced January 5, 2026 that adds real-time in-flight query tracking and enriched role/tag attribution.

Additional ColumnDescription
START_TIME / END_TIMEAggregation window (1-hour buckets)
ROLE_NAMESARRAY – primary active role is index 0
IS_COMPLETEDBOOLEAN – tracks still-running queries
CREDITSCredits at the aggregation window level

Key difference from CORTEX_AISQL_USAGE_HISTORY: Captures running queries updated every ~30 minutes (1-hour SLA). Useful for runaway query detection.

Notable columns for governance: ROLE_NAMES lets you attribute usage to specific roles – critical for chargeback and least-privilege audits.

Coverage starts: January 5, 2026. USER_ID, QUERY_TAG, and ROLE_NAMES available from February 16, 2026 onward.

1.3 CORTEX_ANALYST_USAGE_HISTORY
#

Tracks usage for the Cortex Analyst REST API (text-to-SQL natural language interface).

ColumnDescription
START_TIME / END_TIMERequest received / response sent
REQUEST_COUNTNumber of messages sent to Cortex Analyst
CREDITSCredits billed (per-message pricing, not per-token)
USERNAMEUsername from the authenticated session

Note: Cortex Analyst billing is per-message (not per-token). Token count only affects cost when invoked via Cortex Agents. Data retained for 365 days.

1.4 METERING_HISTORY – AI_SERVICES Service Type
#

All Cortex AI inference also appears in the standard SNOWFLAKE.ACCOUNT_USAGE.METERING_HISTORY view under SERVICE_TYPE = 'AI_SERVICES'. Useful for consolidated credit reporting alongside warehouse and storage costs.

SELECT SERVICE_TYPE, DATE_TRUNC('day', START_TIME) AS usage_date, SUM(CREDITS_USED)
FROM SNOWFLAKE.ACCOUNT_USAGE.METERING_HISTORY
WHERE SERVICE_TYPE = 'AI_SERVICES'
  AND START_TIME >= DATEADD('month', -3, CURRENT_TIMESTAMP())
GROUP BY 1, 2
ORDER BY 2 DESC;

1.5 QUERY_HISTORY – Full SQL Context
#

All Cortex AI Function invocations inside SQL queries also appear in SNOWFLAKE.ACCOUNT_USAGE.QUERY_HISTORY. Join on QUERY_ID to get:

  • Full SQL text (QUERY_TEXT)
  • Session role and user
  • Warehouse, database, schema context
  • Execution status and duration
  • Bytes scanned / rows produced
SELECT q.QUERY_TEXT, q.USER_NAME, q.ROLE_NAME, q.WAREHOUSE_NAME, q.EXECUTION_STATUS
FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_HISTORY q
JOIN SNOWFLAKE.ACCOUNT_USAGE.CORTEX_AISQL_USAGE_HISTORY c ON q.QUERY_ID = c.QUERY_ID
WHERE c.USAGE_TIME >= DATEADD('day', -7, CURRENT_TIMESTAMP());

1.6 Cortex Agent Logs – SNOWFLAKE.LOCAL.AI_OBSERVABILITY_EVENTS
#

Cortex Agents (including those powering Snowflake Intelligence) log detailed execution traces to the event table SNOWFLAKE.LOCAL.AI_OBSERVABILITY_EVENTS. Entries are immutable (cannot be modified; only AI_OBSERVABILITY_ADMIN can delete).

Logged information includes:

  • Full conversation history per thread
  • Execution spans: LLM planning, tool selection, tool execution, SQL execution, chart generation
  • Inputs and outputs at each span
  • User feedback (thumbs up/down per Agent response)

Access control for monitoring:

-- Grant monitoring access to a specific agent
GRANT MONITOR ON AGENT my_agent TO ROLE agent_monitoring_user_role;
GRANT DATABASE ROLE SNOWFLAKE.CORTEX_USER TO ROLE agent_monitoring_user_role;

-- Grant forward-looking access to all agents in a schema
GRANT MONITOR ON FUTURE AGENTS IN SCHEMA mydb.myschema TO ROLE agent_monitoring_user_role;

2. Inference Region Tracking & Control
#

2.1 The CORTEX_ENABLED_CROSS_REGION Parameter
#

This account-level parameter governs where inference requests can be routed when the requested model is not available in the account’s native region.

ValueBehavior
DISABLED (default for most accounts)Inference only in account’s native region
ANY_REGIONRoute to any supported Snowflake region (default for new accounts in new orgs, commercial, created after Mar 9 2026)
AWS_USRoute to AWS US regions only
AWS_EURoute to AWS EU regions only
AWS_US,AWS_EUComma-delimited list of allowed zone groups

Only ACCOUNTADMIN can set this parameter. It cannot be set at user or session level.

-- Restrict to EU-only cross-region (data stays within AWS EU network)
ALTER ACCOUNT SET CORTEX_ENABLED_CROSS_REGION = 'AWS_EU';

-- Lock to home region only (strictest data residency)
ALTER ACCOUNT SET CORTEX_ENABLED_CROSS_REGION = 'DISABLED';

-- Check current setting
SHOW PARAMETERS LIKE 'CORTEX_ENABLED_CROSS_REGION' IN ACCOUNT;

2.2 What Gets Audited for Cross-Region
#

There is no dedicated ACCOUNT_USAGE view column that records which specific region processed a given inference request. Credits are always attributed to the requesting region regardless of where inference ran.

The available signals for inference region compliance are:

SignalWhereWhat It Provides
CORTEX_ENABLED_CROSS_REGION setting changesQUERY_HISTORY (ALTER ACCOUNT SET)Audit trail for policy changes
Model name logged per queryCORTEX_AISQL_USAGE_HISTORY.MODEL_NAMECross-reference against regional model availability to infer if cross-region routing was required
response_metadata.model_names in Cortex Analyst REST API responsesApplication-level loggingPer-request ground truth of which model ran – key for detecting when a cross-region model was selected
"model" field in Cortex LLM REST API completion response bodyApplication-level loggingPer-request model confirmation; shows actual resolved model if aliasing occurred
CORTEX_AISQL_USAGE_HISTORY role attributionROLE_NAMES column (available from Feb 16, 2026)Verify requests came from expected roles with expected model access

The REST API response fields are the most granular per-request audit mechanism available. See Section 8.1 for full details.

2.3 Data Residency Guarantees During Cross-Region
#

ScenarioData Path
Same cloud provider (AWS to AWS)Stays on AWS global backbone plus snowflake uses mTLS for the inference calls
Same cloud provider (Azure to Azure)Stays entirely on Azure global network
Cross-cloud providerTraverses public internet using mTLS
SnowGov regionsCross-region inference is not supported – requests stay in-region
US Commercial GovStays within FIPS-validated infrastructure (AWS Bedrock FIPS endpoints) when AWS_US is set

Prompt and output data is never stored or cached during cross-region inference.


3. RBAC & Access Governance for Cortex AI
#

3.1 Database Roles – The Foundation
#

Snowflake uses three built-in database roles in the SNOWFLAKE database to control Cortex AI access:

Database RoleAccess Granted
SNOWFLAKE.CORTEX_USERAll Cortex AI features (LLM functions, Analyst, Search, Agents)
SNOWFLAKE.CORTEX_ANALYST_USERCortex Analyst only (scoped access)
SNOWFLAKE.CORTEX_ADMINAdmin-level Cortex capabilities

Critical default: SNOWFLAKE.CORTEX_USER is granted to the PUBLIC role by default, meaning all users can access all Cortex AI features unless explicitly revoked.

-- Check current grants on CORTEX_USER
SHOW GRANTS ON DATABASE ROLE SNOWFLAKE.CORTEX_USER;

-- Revoke from PUBLIC to enforce explicit access control
USE ROLE ACCOUNTADMIN;
REVOKE DATABASE ROLE SNOWFLAKE.CORTEX_USER FROM ROLE PUBLIC;

-- Grant only Cortex Analyst access to a specific role
GRANT DATABASE ROLE SNOWFLAKE.CORTEX_ANALYST_USER TO ROLE analyst_team_role;

3.2 Scoping Access to Cortex Analyst Only
#

If users should only be able to use Cortex Analyst (not arbitrary LLM functions), use CORTEX_ANALYST_USER instead of CORTEX_USER:

USE ROLE ACCOUNTADMIN;
-- Remove broad access first
REVOKE DATABASE ROLE SNOWFLAKE.CORTEX_USER FROM ROLE analyst;
-- Grant narrow Analyst-only access
GRANT DATABASE ROLE SNOWFLAKE.CORTEX_ANALYST_USER TO ROLE analyst;

3.3 Per-User Spending Limits via RBAC
#

Access to Cortex features can be revoked programmatically to enforce per-user monthly credit budgets using CORTEX_AI_FUNCTIONS_USAGE_HISTORY:

-- When a user exceeds their monthly limit, revoke their AI role
REVOKE ROLE AI_FUNCTIONS_USER_ROLE FROM USER exceeded_user;
-- Reinstate at the start of next month via a Snowflake Task

4. Model-Level RBAC
#

4.1 Overview (GA – April 2025)
#

Beyond feature-level access, Snowflake supports model-level RBAC using application roles. Each supported LLM has a corresponding role in the SNOWFLAKE database:

SNOWFLAKE."CORTEX-MODEL-ROLE-<MODEL-SLUG>"

Examples:

  • SNOWFLAKE."CORTEX-MODEL-ROLE-CLAUDE-SONNET"
  • SNOWFLAKE."CORTEX-MODEL-ROLE-LLAMA3-1-70B"
  • SNOWFLAKE."CORTEX-MODEL-ROLE-ARCTIC-TRANSLATE"
  • SNOWFLAKE."CORTEX-MODEL-ROLE-MISTRAL-LARGE2"

4.2 CORTEX_MODELS_ALLOWLIST Parameter
#

A complementary account-level parameter that provides allowlist/blocklist-style control:

SettingBehavior
'All' (default)All models are accessible to users with CORTEX_USER
'None'No models allowed via allowlist; RBAC roles are the only path
'llama3.1-70b,mistral-large2'Only listed models are accessible to all users
-- Check current allowlist
SHOW PARAMETERS LIKE 'CORTEX_MODELS_ALLOWLIST' IN ACCOUNT;

-- Restrict to specific models (allowlist approach)
ALTER ACCOUNT SET CORTEX_MODELS_ALLOWLIST = 'llama3.1-70b,mistral-large2,arctic-translate';

-- Switch to pure RBAC mode (no allowlist)
ALTER ACCOUNT SET CORTEX_MODELS_ALLOWLIST = 'None';

4.3 Enforcement Logic (BCR-2220 – 2026_02 Bundle)
#

As of the 2026_02 behavior change bundle (BCR-2220), model RBAC and CORTEX_MODELS_ALLOWLIST are enforced across all Cortex AI Functions, not just AI_COMPLETE. The enforcement order is:

  1. Check model RBAC (application role) – if role grants access, ALLOW
  2. Check CORTEX_MODELS_ALLOWLIST – if model is listed (or = 'All'), ALLOW
  3. Otherwise – FAIL with model-authorization error

Functions now fully enforcing model RBAC (newly added in BCR-2220): AI_TRANSCRIBE, AI_EXTRACT, AI_SENTIMENT, AI_TRANSLATE, CLASSIFY_TEXT, SUMMARIZE, EXTRACT_ANSWER, AI_PARSE_DOCUMENT, AI_REDACT

Functions that already enforced RBAC (pre-BCR-2220): AI_COMPLETE / COMPLETE, AI_CLASSIFY, AI_FILTER, AI_AGG, AI_SUMMARIZE_AGG

To prepare for or audit BCR-2220 exposure:

-- Check which affected functions are in use
SELECT DISTINCT FUNCTION_NAME
FROM SNOWFLAKE.ACCOUNT_USAGE.CORTEX_AISQL_USAGE_HISTORY
WHERE USAGE_TIME >= DATEADD('day', -90, CURRENT_TIMESTAMP())
  AND FUNCTION_NAME IN (
      'AI_TRANSCRIBE', 'TRANSCRIBE', 'AI_EXTRACT', 'AI_SENTIMENT',
      'SENTIMENT', 'ENTITY_SENTIMENT', 'AI_TRANSLATE', 'TRANSLATE',
      'CLASSIFY_TEXT', 'SUMMARIZE', 'EXTRACT_ANSWER',
      'AI_PARSE_DOCUMENT', 'PARSE_DOCUMENT', 'AI_REDACT'
  )
ORDER BY FUNCTION_NAME;

4.4 Function-to-Model Alias Mapping
#

Managed functions (non-AI_COMPLETE) use internal model aliases confirmed via BCR-2220 documentation. These must be explicitly permitted if CORTEX_MODELS_ALLOWLIST is not 'All':

FunctionModel AliasConfirmed?
AI_TRANSLATE / TRANSLATEarctic-translateYes – BCR-2220
AI_TRANSCRIBE / TRANSCRIBEarctic-transcribeYes – BCR-2220
AI_EXTRACT / EXTRACT_ANSWERarctic-extract / arctic-extract-answerYes – BCR-2220 + docs
AI_PARSE_DOCUMENT / PARSE_DOCUMENTarctic-parse-documentYes – BCR-2220
AI_SENTIMENT / SENTIMENT / ENTITY_SENTIMENTarctic-sentimentYes – BCR-2220
CLASSIFY_TEXT, AI_REDACTllama3.1-70bYes – BCR-2220
SUMMARIZEmistral-7bYes – BCR-2220
AI_CLASSIFY, AI_FILTER, AI_AGG, AI_SUMMARIZE_AGGNot disclosed – “Snowflake managed model”Model identity not published

Important: AI_CLASSIFY, AI_FILTER, AI_AGG, and AI_SUMMARIZE_AGG already enforced model RBAC before BCR-2220. Their underlying model is documented only as “Snowflake managed model” – Snowflake does not publish the specific model identifier. If CORTEX_MODELS_ALLOWLIST is set to anything other than 'All', these functions may fail unless the managed model is implicitly permitted. See Section 9.3 for detail.


5. EU-Only Inference: Impact Across Cortex Services
#

5.1 Available EU Regions (Native)
#

Snowflake Cortex AI is natively available in the following EU regions:

  • AWS eu-central-1 (Frankfurt)
  • AWS eu-west-1 (Ireland)
  • Azure West Europe (Netherlands)

For accounts in other EU regions (e.g., AWS eu-west-3 Paris, Azure North Europe), cross-region inference must be enabled to access models not natively supported there.

5.2 Restricting to EU-Only Inference
#

For strict EU data residency (e.g., GDPR compliance requirements where data must stay in the EU):

-- Allow cross-region only within AWS EU zones
ALTER ACCOUNT SET CORTEX_ENABLED_CROSS_REGION = 'AWS_EU';

-- OR lock entirely to home region (no cross-region at all)
ALTER ACCOUNT SET CORTEX_ENABLED_CROSS_REGION = 'DISABLED';

5.3 Model Availability Impact by Service
#

When CORTEX_ENABLED_CROSS_REGION = 'DISABLED' or = 'AWS_EU', only models natively available in the account’s region (or within the EU zone) can be used. Models hosted exclusively in US regions may not be accessible.

Cortex ServiceEU Restriction Impact
Cortex AI Functions (AI_COMPLETE etc.)Only EU-available models can be used; calls to US-only models fail with “model not available in region” error
Cortex AnalystModel fallback chain may be reduced (see Section 6); requests fail if no accessible model remains
Cortex AgentsAgent orchestration that calls restricted models will fail; Snowflake Intelligence affected if default models are EU-unavailable
Cortex SearchCross-region inference is not supported for Cortex Search – it is always in-region
AI ObservabilityLLM judges run via AI_COMPLETE – restricted model sets affect which judges can be used for evaluation

6. Cortex Analyst: Fallback Model Chain & RBAC Interaction
#

6.1 Model Selection Behavior
#

Cortex Analyst automatically selects the best available model per request. Users cannot specify a model directly. Snowflake evaluates the following factors in combination:

  • Models natively available in the account’s region
  • The account’s CORTEX_ENABLED_CROSS_REGION setting
  • Any model-level RBAC restrictions on the calling role

6.2 Cortex Analyst Model Fallback Priority (Current as of April 2026)
#

Cortex Analyst selects the highest-ranked model the calling role has access to:

PriorityModel
1Anthropic Claude Sonnet 4
2Anthropic Claude Sonnet 3.7
3Anthropic Claude Sonnet 3.5
4OpenAI GPT 4.1
5Arctic Text2SQL R1.5 (with thinking)
6Mistral Large 2 + Llama 3.1 70b (combination)

Warning: Snowflake may update this model selection chain over time to take advantage of advances in model capability. This can cause result variance across time if model availability or RBAC changes.

6.3 RBAC + Region = Failure Risk
#

The three controls multiply together. The following combinations can cause complete Cortex Analyst failures:

ScenarioEffect
EU account + DISABLED cross-region + Top models (Claude/GPT) not in EUFalls back to Arctic R1.5 or Mistral/Llama combo
EU account + All Anthropic/OpenAI models blocked by CORTEX_MODELS_ALLOWLISTFalls back to Arctic R1.5 or Mistral/Llama
EU account + Model RBAC revokes all models the calling role can useRequest fails entirely with model-authorization error
CORTEX_MODELS_ALLOWLIST = 'None' + No model application roles grantedEvery Cortex Analyst request fails

Recommended governance posture for EU deployments:

-- Ensure at minimum the Arctic and Mistral-family models are accessible for fallback
ALTER ACCOUNT SET CORTEX_MODELS_ALLOWLIST =
  'llama3.1-70b,mistral-large2,arctic-text2sql-r1,arctic-translate,arctic-extract,arctic-sentiment';

-- OR grant model roles explicitly
GRANT APPLICATION ROLE SNOWFLAKE."CORTEX-MODEL-ROLE-MISTRAL-LARGE2" TO ROLE analyst_role;
GRANT APPLICATION ROLE SNOWFLAKE."CORTEX-MODEL-ROLE-LLAMA3-1-70B" TO ROLE analyst_role;

Important: Model-level restrictions apply across all Cortex features – it is not possible to restrict a model only in Cortex Analyst while keeping it accessible in AI_COMPLETE.

6.4 Controlling Consistency of Results
#

Different models produce different SQL and natural language responses. For reproducible, consistent Cortex Analyst results in regulated environments:

  • Pin CORTEX_ENABLED_CROSS_REGION to a fixed zone
  • Use CORTEX_MODELS_ALLOWLIST or RBAC roles to maintain a fixed model set
  • Monitor CORTEX_ANALYST_USAGE_HISTORY for request counts and credit patterns

7. AI Observability & Tracing
#

7.1 TruLens-Based Evaluation
#

Snowflake AI Observability (GA) provides LLM-as-a-judge evaluation for generative AI applications, powered by TruLens. This enables:

  • Systematic benchmarking (accuracy, latency, cost)
  • Side-by-side comparison of models, prompts, inference configs
  • Step-by-step tracing (prompt -> retrieval -> tool use -> response)

Required privileges:

  • CORTEX_USER database role
  • CREATE EXTERNAL AGENT on the schema
  • CREATE TASK and EXECUTE TASK global privilege

Application representation: Each AI application is represented as an EXTERNAL AGENT object in Snowflake, which governs access to its traces and evaluation results.

7.2 Trace Storage
#

Execution traces and evaluation results are stored in the Snowflake event table for the account. Evaluation runs themselves invoke SNOWFLAKE.CORTEX.COMPLETE – meaning evaluation costs appear in CORTEX_AISQL_USAGE_HISTORY and are subject to the same model RBAC constraints.


8. REST API Audit Coverage
#

Cortex AI services expose REST APIs that can be called from outside Snowflake. Here is how each is covered in the audit layer:

REST APIAudit Coverage
Cortex Analyst API (/api/v2/cortex/analyst/message)CORTEX_ANALYST_USAGE_HISTORY (per-message billing + username)
Cortex Agent API (/api/v2/cortex/agents)SNOWFLAKE.LOCAL.AI_OBSERVABILITY_EVENTS (full trace logging)
Cortex LLM REST API (/api/v2/cortex/inference:complete, /api/v2/cortex/v1/chat/completions, /api/v2/cortex/v1/messages)CORTEX_AISQL_USAGE_HISTORY / CORTEX_AI_FUNCTIONS_USAGE_HISTORY
Cortex Search (via REST)CORTEX_SEARCH_SERVING_USAGE_HISTORY; SQL invocations also in QUERY_HISTORY

Authentication: All REST API requests require an authorization token (OAuth, key-pair JWT, or PAT). The authenticated username/user ID flows through to all usage history views.

8.1 Per-Request Inference Model Signals in REST API Responses
#

This is a critical capability for auditing which model actually ran for a given request – especially relevant when Cortex Analyst’s automatic fallback chain or cross-region inference is in play.

Cortex LLM REST API – "model" field in response body

Every completion response includes a "model" field that reflects the actual model that processed the request – not necessarily the one you requested, if aliasing or selection occurred:

{
  "choices": [
    { "messages": "Your response here" }
  ],
  "created": 1714497970,
  "model": "claude-4-sonnet",
  "usage": {
    "completion_tokens": 65,
    "prompt_tokens": 17,
    "total_tokens": 82
  }
}

Use this field to verify:

  • Which model in a multi-model setup was actually invoked
  • Whether cross-region inference resulted in a different model being selected
  • Compliance with RBAC restrictions (confirm a restricted model was not used)

Streaming responses deliver the same information via the response_metadata server-sent event emitted at the end of the stream.

Cortex Analyst REST API – response_metadata.model_names

The Cortex Analyst API response includes a response_metadata object that directly exposes which model(s) were selected for that request. This is the key audit field for verifying which step of the fallback chain fired:

{
  "request_id": "75d343ee-699c-483f-83a1-e314609fb563",
  "message": {
    "role": "analyst",
    "content": [
      { "type": "text", "text": "We interpreted your question as ..." },
      { "type": "sql", "statement": "SELECT * FROM table" }
    ]
  },
  "response_metadata": {
    "model_names": ["claude-3-5-sonnet"],
    "question_category": "CLEAR_SQL",
    "cortex_search_retrieval": []
  }
}
response_metadata FieldWhat It Tells You
model_namesArray of model IDs actually used. If Analyst used multiple models (e.g., one for planning, one for SQL), all appear here.
question_categoryHow Analyst classified the question: CLEAR_SQL, AMBIGUOUS, etc. Useful for quality monitoring.
cortex_search_retrievalDetails of any Cortex Search service calls made during the request.

In streaming mode, response_metadata is delivered as a distinct server-sent event:

event: response_metadata
data: { "model_names": ["claude-4-sonnet"], "question_category": "CLEAR_SQL" }

event: done

Governance use cases for response_metadata.model_names:

  • EU compliance audit: Log every Analyst response and alert if model_names contains claude-* or openai-* on an account configured to use only native models – this indicates cross-region inference fired or RBAC was misconfigured
  • Fallback chain monitoring: Track when Analyst degrades from Claude Sonnet 4 to lower-priority models – a signal of RBAC over-restriction or regional model unavailability
  • Result reproducibility: model_names in the response is the ground truth for which model generated a given SQL – critical for debugging result variance

8.2 Capturing response_metadata for Audit Logging
#

Since CORTEX_ANALYST_USAGE_HISTORY does not currently store the resolved model name (only request counts and credits), the only way to get per-request model attribution for Cortex Analyst is from the REST API response body itself. Applications calling the Analyst REST API should log response_metadata.model_names alongside the request_id:

import requests
import json

response = requests.post(
    f"https://{account}.snowflakecomputing.com/api/v2/cortex/analyst/message",
    headers={
        "Authorization": f"Bearer {token}",
        "Content-Type": "application/json",
    },
    json={
        "messages": [
            {"role": "user", "content": [{"type": "text", "text": question}]}
        ],
        "semantic_model_file": "@db.schema.stage/model.yaml",
    },
)

body = response.json()
request_id   = body.get("request_id")
models_used  = body.get("response_metadata", {}).get("model_names", [])
question_cat = body.get("response_metadata", {}).get("question_category")

# Log for audit trail
print(f"request_id={request_id} models={models_used} category={question_cat}")

The request_id returned in the response is also the correlation key if Snowflake adds per-request model resolution to CORTEX_ANALYST_USAGE_HISTORY in future.


9. Model Catalog: Hosting Infrastructure & Data Sovereignty
#

9.1 Hosting Architecture Overview
#

Snowflake’s official position – and the contractually correct statement – is that all models available through Cortex AI run within the Snowflake security perimeter and governance boundary. As the Cortex REST API documentation states: “All inference runs within the Snowflake perimeter, so your data remains secure and within your governance boundary.” This applies uniformly to every model in the catalog, regardless of the underlying compute tier.

The underlying compute infrastructure varies by model vendor, but in all cases Snowflake manages the security envelope, authentication, audit, and data handling obligations:

Infrastructure TierModelsNotes
Snowflake-Native GPU ClustersMeta Llama family, Mistral family, DeepSeek R1, Snowflake Arctic, SwiftKV-optimized variantsInference runs on hardware Snowflake owns and operates.
AWS Bedrock (within Snowflake’s perimeter)Anthropic Claude familyBacked by Snowflake’s $200M strategic partnership with Anthropic. Inference is mediated through Snowflake’s governance layer on AWS.
Azure AI Foundry / Azure OpenAI (within Snowflake’s perimeter)OpenAI GPT and o-series familyOpenAI’s primary cloud infrastructure is Azure. Snowflake accesses these via Azure AI Foundry, fully within the Snowflake governance envelope.

The distinction between tiers matters primarily for region availability – not governance. Anthropic and OpenAI models are only available natively in the specific regions where AWS Bedrock / Azure AI Foundry host them. For EU accounts, this means cross-region inference may be required to reach Claude or GPT models even though data never escapes Snowflake’s governance boundary.

9.2 Complete Model Catalog – AI_COMPLETE / COMPLETE (as of April 2026)
#

Anthropic – Claude Family (via AWS Bedrock)
#

Model IDGenerationContext WindowNotes
claude-4-opusClaude 4200KPreview. Best-in-class coding & long-horizon agentic tasks.
claude-4-sonnetClaude 4200KGA. Default for Cortex Analyst (top priority).
claude-3-7-sonnetClaude 3.7200KGA. Extended thinking with tool use. Analyst fallback #2.
claude-3-5-sonnetClaude 3.5200KGA. Strong accuracy/latency balance. Analyst fallback #3.
claude-haiku-4-5Claude 4200KFast/lightweight Haiku variant.
claude-sonnet-4-6Claude 4200KLatest Sonnet point release.

Data flow: Request metadata + prompt -> Snowflake perimeter -> Anthropic inference on AWS Bedrock -> response back through Snowflake. EU impact: AWS Bedrock availability in EU regions determines whether these models are natively accessible from EU Snowflake accounts.

OpenAI – GPT & o-Series Family (via Azure AI Foundry / Azure OpenAI)
#

Model IDSeriesContext WindowNotes
openai-gpt-4.1GPT-4.1128KGA. Cortex Analyst fallback #4.
openai-gpt-5GPT-5TBDFull GPT-5 flagship model.
openai-gpt-5-chatGPT-5TBDChat-optimized variant.
openai-gpt-5-miniGPT-5TBDEfficient mid-tier variant.
openai-gpt-5-nanoGPT-5TBDSmallest/fastest variant.
openai-gpt-5.1GPT-5.1TBDPoint release.
openai-o4-minio4128KReasoning-optimized; strong at STEM tasks.

Data flow: Request metadata + prompt -> Snowflake perimeter -> Azure AI Foundry / Azure OpenAI -> response back through Snowflake. EU impact: Azure OpenAI EU region availability determines native access. CORTEX_ENABLED_CROSS_REGION = 'AZURE_EU' routes to Azure EU regions.

Meta – Llama Family (Snowflake-Native GPU Infrastructure)
#

Model IDParamsContext WindowNotes
llama4-maverick~400B MoE128KLatest Llama 4. Multimodal-capable.
llama4-scout~109B MoE128KEfficient MoE variant.
llama3.1-405b405B128KState-of-the-art open model.
llama3.1-70b70B128KStrong general-purpose; Analyst combo model.
llama3.1-8b8B128KFast, lightweight.
llama3.3-70b70B128KImproved 70B benchmarks.
llama3-70b70B8KLegacy 70B. Still supported.
llama3-8b8B8KLegacy 8B. Still supported.

Data flow: Entirely within Snowflake’s own GPU infrastructure. EU impact: Natively available in EU Snowflake regions. EU accounts with DISABLED cross-region can still use all Llama models.

Snowflake – Proprietary & SwiftKV-Optimized Models (Snowflake-Native)
#

Model IDBaseNotes
snowflake-arcticSnowflake ArcticSnowflake’s own MoE model; optimized for enterprise SQL and data tasks. 4K context.
snowflake-llama-3.1-405bLlama 3.1 405BSwiftKV-optimized: up to 75% inference cost reduction with minimal accuracy loss.
snowflake-llama-3.3-70bLlama 3.3 70BSwiftKV-optimized; higher throughput, lower cost.

Also used internally:

  • arctic-text2sql-r1 – Arctic Text2SQL R1.5 with thinking (Cortex Analyst fallback #5)
  • arctic-translate, arctic-extract, arctic-sentiment, arctic-parse-document, arctic-extract-answer, arctic-transcribe – Managed function model aliases

Data flow: Entirely within Snowflake’s own GPU infrastructure. EU impact: Natively available in EU regions. SwiftKV models recommended for cost-sensitive EU deployments.

Mistral AI – Mistral Family (Snowflake-Native GPU Infrastructure)
#

Model IDParamsContext WindowNotes
mistral-large2~123B128KFlagship Mistral; Analyst combo model. Strong multilingual.
mistral-large~123B32KLegacy large model.
mixtral-8x7b8x7B MoE32KFast MoE; good for text gen, classification.
mistral-7b7B32KLightest/fastest; used internally by SUMMARIZE.

Data flow: Entirely within Snowflake’s own GPU infrastructure. EU impact: Mistral is a French AI company – all Mistral models are natively available in EU Snowflake regions with no cross-region inference required.

DeepSeek – Reasoning Family (Snowflake-Native GPU Infrastructure)
#

Model IDNotes
deepseek-r1Open-source reasoning model with chain-of-thought. Strong at math, code, and structured reasoning.

Data flow: Hosted on Snowflake’s native GPU infrastructure (open-source weights). EU impact: Natively hosted; available in EU regions. Note: DeepSeek is a Chinese AI lab – enterprises with geopolitical data concerns should be aware, though inference runs entirely on Snowflake’s infrastructure.

9.3 Managed Function Model Aliases
#

The task-specific AI Functions do not accept a model argument directly – they use Snowflake-managed internal model aliases. This group splits into two tiers based on what Snowflake publicly documents.

Tier A – Model alias publicly confirmed (via BCR-2220 documentation)

All are Snowflake-native infrastructure:

FunctionInternal Model AliasInfrastructure
AI_TRANSLATE / TRANSLATEarctic-translateSnowflake-native
AI_TRANSCRIBE / TRANSCRIBEarctic-transcribeSnowflake-native
AI_EXTRACT / EXTRACT_ANSWERarctic-extract / arctic-extract-answerSnowflake-native
AI_PARSE_DOCUMENT / PARSE_DOCUMENTarctic-parse-documentSnowflake-native
AI_SENTIMENT / SENTIMENT / ENTITY_SENTIMENTarctic-sentimentSnowflake-native
CLASSIFY_TEXT, AI_REDACTllama3.1-70bSnowflake-native (Meta Llama)
SUMMARIZEmistral-7bSnowflake-native (Mistral)

Tier B – “Snowflake managed model” (underlying model NOT publicly disclosed)

FunctionDocumented ModelContext WindowNotes
AI_CLASSIFY (text)Snowflake managed model128KRBAC-enforced; model not named
AI_CLASSIFY (image)Snowflake managed model128KOnly available in ~3 regions – strongly implies a multimodal frontier model
AI_FILTER (text/image)Snowflake managed model128KRBAC-enforced; model not named
AI_AGGSnowflake managed model128K per rowRBAC-enforced; model not named
AI_SUMMARIZE_AGGSnowflake managed model128K per rowRBAC-enforced; model not named

Governance implication: These functions were already subject to CORTEX_MODELS_ALLOWLIST and model RBAC enforcement before BCR-2220. Snowflake’s choice not to disclose the specific model identity makes it impossible to confirm whether these use Snowflake-native infrastructure or a frontier model tier. The image classification variant’s very limited regional availability is a strong signal it relies on a multimodal frontier model. All executions remain within Snowflake’s governance perimeter regardless.

9.4 Data Sovereignty Summary by Model Family
#

Model FamilyCompute TierEU-Native AvailabilityNotes
Llama (Meta)Snowflake-nativeYes – all EU regionsFully on Snowflake infrastructure
Snowflake Arctic / SwiftKVSnowflake-nativeYes – all EU regionsSnowflake’s own model family
Mistral / MixtralSnowflake-nativeYes – all EU regionsFrench AI lab; natively hosted
DeepSeek R1Snowflake-nativeYes – all EU regionsOpen-source weights; hosted by Snowflake
Claude (Anthropic)AWS Bedrock (Snowflake perimeter)AWS eu-central-1, eu-west-1 onlyRequires cross-region for other EU regions
GPT / o-series (OpenAI)Azure AI Foundry (Snowflake perimeter)Azure West Europe onlyRequires cross-region for other Azure EU regions

For strict in-region processing requirements: Use only Snowflake-native models (Llama, Arctic, Mistral, DeepSeek) and set CORTEX_ENABLED_CROSS_REGION = 'DISABLED'. All governance obligations are met with any model – but native models avoid any cross-region routing entirely.

9.5 Model Availability via REST API
#

All models available via SQL AI_COMPLETE / COMPLETE are also accessible through the Snowflake Cortex REST API:

POST https://<account>.snowflakecomputing.com/api/v2/cortex/inference:complete
Authorization: Bearer <token>
Content-Type: application/json

{
  "model": "claude-4-sonnet",
  "messages": [{"role": "user", "content": "..."}]
}

Authentication uses the same Snowflake session tokens (OAuth, key-pair JWT). The same RBAC model restrictions (CORTEX_MODELS_ALLOWLIST and model application roles) apply to REST API calls identically to SQL calls. REST API usage appears in CORTEX_AISQL_USAGE_HISTORY.


10. Summary Matrix
#

Governance ControlWhere ConfiguredWho Can ConfigureAudit View
Feature-level AI accessSNOWFLAKE.CORTEX_USER / CORTEX_ANALYST_USER database rolesACCOUNTADMINQUERY_HISTORY (GRANT/REVOKE)
Model allowlistCORTEX_MODELS_ALLOWLIST account parameterACCOUNTADMINQUERY_HISTORY (ALTER ACCOUNT)
Model RBAC (fine-grained)SNOWFLAKE."CORTEX-MODEL-ROLE-*" application rolesACCOUNTADMINQUERY_HISTORY
Cross-region inference routingCORTEX_ENABLED_CROSS_REGION account parameterACCOUNTADMINQUERY_HISTORY (ALTER ACCOUNT)
Cortex AI Function usage––CORTEX_AISQL_USAGE_HISTORY, CORTEX_AI_FUNCTIONS_USAGE_HISTORY
Cortex Analyst usage––CORTEX_ANALYST_USAGE_HISTORY
Cortex Agent traces––SNOWFLAKE.LOCAL.AI_OBSERVABILITY_EVENTS
Per-user AI spending limitsCustom role + Snowflake TaskACCOUNTADMINCORTEX_AI_FUNCTIONS_USAGE_HISTORY
AI evaluation/tracingAI Observability (TruLens)Schema ownerEvent table
Cortex Analyst disabled entirelyENABLE_CORTEX_ANALYST = FALSEACCOUNTADMINQUERY_HISTORY

Key Takeaways for Enterprise Deployments
#

  • Default is open: SNOWFLAKE.CORTEX_USER is granted to PUBLIC by default – explicitly revoke and re-grant to enforce least-privilege.
  • EU residency requires active configuration: Without CORTEX_ENABLED_CROSS_REGION = 'DISABLED' or 'AWS_EU', inference requests can route to US regions.
  • Cortex Analyst can silently degrade: If RBAC or region settings block the top models in the fallback chain, Analyst falls back to lower-capability models – or fails entirely if the entire chain is blocked. This is a silent quality risk, not always a visible error.
  • BCR-2220 is a breaking change: If CORTEX_MODELS_ALLOWLIST is customized and AI_TRANSLATE, AI_SENTIMENT, or similar functions are in use, those calls will start failing when the 2026_02 bundle is enabled unless the relevant model aliases are added to the allowlist.
  • No direct inference-region attribution in logs: Credits are always billed to the requesting region. There is currently no per-query log field indicating which remote region actually processed the inference.
  • CORTEX_AI_FUNCTIONS_USAGE_HISTORY is the most powerful view for real-time governance: it captures in-flight queries, role attribution, and supports automated runaway-query cancellation patterns.

References:

Kevin Keller
Author
Kevin Keller
Personal blog about AI, Observability & Data Sovereignty. Snowflake-related articles explore the art of the possible and are not official Snowflake solutions or endorsed by Snowflake unless explicitly stated. Opinions are my own. Content is meant as educational inspiration, not production guidance.
Share this article

Related

Federal Zero Trust Architecture Blueprint — Snowflake as the AI + Data Control Plane

Snowflake provides a unified Zero Trust control plane for both data and AI inference. This blueprint maps Snowflake and Cortex to NIST 800-207, CISA’s Zero Trust Maturity Model, and OMB M-22-09 — one governance layer, one policy stack, no shadow AI.

Snowflake Container Services Deep Dive — Security, Networking, and Tunneling

A comprehensive deep dive into Snowflake Container Services — security architecture, compute isolation, ingress/egress controls, PAT authentication, CORS, private connectivity, and tunneling approaches (Data Connectivity Proxy, SSH, WebSocket, Tailscale, ngrok) to connect SPCS to your own infrastructure. Updated November 2026.