Skip to content

Snowflake Cortex AI & Agents

Last reviewed: October 2026

What's changed recently

  • Snowflake Intelligence is now Snowflake CoWork (renamed June 2026), the end-user surface for Cortex Agents. Cortex Code is the AI coding assistant and is replacing Snowflake Copilot.
  • "Cortex AI Functions" is the official name for the SQL AI surface (formerly marketed as Cortex AISQL). It now includes AI_EXTRACT, AI_PARSE_DOCUMENT, AI_REDACT, AI_TRANSCRIBE, AI_SUMMARIZE, and AI_MULTI_EMBED. Document AI was decommissioned in March 2026 in favor of AI_EXTRACT.
  • MCP works in both directions. A Snowflake-managed MCP server (GA November 2025) exposes Cortex tools to external clients, and agents can call remote MCP servers through MCP connectors (GA mid-2026).
  • Agent operations matured: Cortex Agent evaluations reached GA in March 2026, and background agent runs (up to 6 hours) work with threads.

A deep, production-focused interview guide for Snowflake Cortex AI — the LLM/ML layer that runs next to your data, inside Snowflake's governance perimeter. This section goes beyond the overview on the Snowflake technology page: here we build mental models for Cortex Agents, Cortex Analyst (text-to-SQL over semantic views), Cortex Search (native RAG retrieval), the AISQL functions, and the security / cost / observability story an interviewer will probe.

Currency note

Cortex features ship fast and names change. The patterns here (agentic orchestration, semantic models, hybrid retrieval, governed-in-perimeter AI) are stable, but treat specific capability claims as "as of current Snowflake docs" and verify against Snowflake's official Cortex documentation (docs.snowflake.com) before an interview. This guide was checked against Snowflake's official Cortex Agents documentation. Content was rephrased for compliance with licensing restrictions.

The one-sentence pitch

Cortex lets you run LLM inference, semantic search, and full agentic workflows on governed data without moving it out of Snowflake — the same RBAC, masking policies, tags, and audit trail that protect your tables also protect every AI call.


The Cortex landscape

Cortex is a stack, not a single product. Interviewers want to see that you know which layer solves which problem.

flowchart TB
    subgraph PERIMETER[Snowflake governance perimeter - RBAC, masking, tags, audit]
        subgraph DATA[Your data]
            STRUCT[(Structured tables)]
            UNSTRUCT[(Docs, transcripts, PDFs)]
        end
        subgraph FUNC[Cortex AI Functions]
            LLM[AI_COMPLETE, AI_CLASSIFY, AI_FILTER, AI_AGG, AI_EXTRACT, AI_SENTIMENT ...]
            EMB[AI_EMBED / vector ops]
        end
        subgraph RETR[Retrieval + NL query]
            SEARCH[Cortex Search - hybrid retrieval over unstructured]
            ANALYST[Cortex Analyst - text-to-SQL over semantic views]
        end
        subgraph AGENT[Cortex Agents - managed agentic platform]
            ORCH[Orchestrator LLM: plan / use tools / reflect]
        end
    end
    STRUCT --> ANALYST
    UNSTRUCT --> SEARCH
    UNSTRUCT --> FUNC
    ANALYST --> AGENT
    SEARCH --> AGENT
    FUNC --> AGENT
    AGENT --> APPS[Snowflake CoWork / Cortex Code / your app via REST API]
Layer What it is When you reach for it
Cortex AI Functions (AISQL) Call LLMs and embeddings directly in SQL — newer AI_* family (AI_COMPLETE, AI_CLASSIFY, AI_FILTER, AI_AGG, AI_EMBED, AI_EXTRACT, …) and legacy SNOWFLAKE.CORTEX.* (COMPLETE, SUMMARIZE, SENTIMENT, EMBED_TEXT_*). See the functions & API reference. Batch enrichment, classification, extraction over columns — set-based AI
Cortex Search Managed hybrid (vector + keyword) retrieval service over text The RAG retrieval engine; grounding for chatbots and agents
Cortex Analyst Natural language → governed SQL over a semantic view/model Self-serve analytics, "ask your data" over structured tables
Cortex Agents Fully managed agentic platform: an orchestrator LLM that plans, calls tools, runs code, and responds Multi-step questions that mix structured + unstructured data and actions
Snowflake CoWork / Cortex Code CoWork (formerly Snowflake Intelligence) is the business-user agent chat; Cortex Code is the developer coding assistant The UX layer; you also call agents from your own app via REST API or MCP

The three questions that pick the layer

  1. Is the answer in structured tables? → Cortex Analyst (needs a semantic view).
  2. Is the answer in documents/text? → Cortex Search (native RAG).
  3. Does it need both, plus reasoning, tool calls, or actions? → a Cortex Agent that uses Analyst and Search as tools.

Why "AI next to the data" is the whole story

The differentiator versus bolting an external LLM app onto Snowflake:

  • No data egress. Inference happens inside the account; sensitive columns never leave the perimeter to hit a third-party endpoint.
  • Governance is inherited, not re-implemented. RBAC roles, dynamic data masking, row-access policies, and object tags apply to the data an AI call touches. You don't rebuild access control in an app tier.
  • Auditability. Access History and query history cover AI calls and agent tool use, so you can answer "who asked what, over which data."
  • Least data movement = less attack surface + lower cost (no duplicate vector store to secure, sync, and pay for separately).

Interview framing

When asked "why Cortex over a LangChain app on top of Snowflake?", lead with governance and data gravity, not model quality: "The models are comparable; the win is that the security and compliance boundary already exists around the data, so I inherit it instead of rebuilding it in an app tier — and I avoid egress." Then acknowledge the trade-off (below).


Honest trade-offs (say these before the interviewer does)

A senior candidate names the limits, not just the benefits:

  • Model / provider choice is curated, not arbitrary. You pick from the models Snowflake offers (or let it auto-select), not any model on the internet.
  • Region / availability — specific functions and models roll out by region; check availability for your account before promising a capability.
  • Cost is credit-based and can surprise you — large-model calls over big columns are expensive; you design for it (batching, cheaper models, filters).
  • You're inside Snowflake's runtime — great for governance, but heavy custom orchestration or non-SQL glue may still want an app tier calling the REST API.