
Building with Sigma + Claude
October 7, 2026
Best Embedded Analytics Tools for SaaS in 2026
October 13, 2026Sigma Agents and Snowflake Agents: What They Are and When to Use Each
As a Sigma implementation partner, we’re hearing a new question from data teams: “We run on Snowflake and we use Sigma. If we build an AI agent, where should it live?”
The confusion is only natural. Both tools are agents that you’re able to program to perform autonomous tasks with your data, so it might seem like they’re duplicative in nature.
They aren’t. This post walks through what each product is, how you build with them, where your people use it, and how security and cost work. Then we cover what each one does best and when to reach for it.
First, a quick note on names
Both companies now ship more than one AI product, and Snowflake renamed most of its lineup in 2026. Here’s who’s who before we compare anything.
Sigma’s lineup:
- Sigma Agents are custom agents you build and add to a workbook to empower the end users, each with its own data sources, tools, and instructions. Today every agent lives in a workbook, but Sigma has previewed agents that stand on their own, outside of any individual workbook.
- Sigma Assistant is the AI built into every workbook. It does two jobs: building dashboards and apps from prompts, and analyzing workbook data in plain language.
Snowflake’s lineup:
- Cortex Agents are the build layer. A Cortex Agent is an object you define inside Snowflake that bundles a model, tools, and instructions.
- Snowflake CoWork is where business users chat with those agents. It was called Snowflake Intelligence until Snowflake renamed it at Summit in June 2026.
- Snowflake CoCo is the new name for Cortex Code, Snowflake’s AI coding agent. Snowflake says the rename changed nothing about how it works.
Where CoCo lands: CoCo is a tool for builders, not an agent your business users talk to. It sits in the same category as Claude Code or Cursor, helping engineers write SQL, build pipelines, and even build agents. Its closest Sigma counterpart is Sigma Assistant in build mode, though Assistant builds Sigma dashboards and apps rather than code. We cover each lineup in turn, then map them side by side in Part 3.
Part 1: Sigma (Sigma Agents and Sigma Assistant)
Most of this section covers Sigma Agents, the closest match to Cortex Agents. Sigma Assistant gets its own short section at the end.
What it is
A Sigma Agent is an AI agent you build inside a Sigma workbook. It reasons over live warehouse data, takes action in your other systems, and can write results back to the warehouse. Because it lives in Sigma, it uses the same governed connections, data models, and permissions as your dashboards and apps.
Sigma Agents also aren’t tied to one data platform. A single agent can use Snowflake Cortex Agents and Databricks Genie Agents as tools, side by side.
How you build one
Every Sigma Agent has three parts, configured in the workbook editor under Agents (docs):
- Data sources give the agent context. You add workbook elements or data model tables, and the agent only knows about the data you add.
- Tools define what the agent can do: workbook actions and action sequences, warehouse agents (Snowflake Cortex Agents or Databricks Genie Agents), warehouse search services (Cortex Search or Databricks Vector Search), and MCP connectors to tools like Jira, Slack, or SharePoint.
- Instructions describe the agent’s job in plain language and tell it when to use each tool.
You don’t start from a blank page. The Agent builder assistant drafts instructions, suggests data sources, and sets up action tools from a conversational prompt. If the workbook already holds data, it suggests agent templates based on that data.
For engineers: building an agent requires the Manage agents and Create, edit, and publish workbooks permissions, plus Can edit access to the workbook. Adding MCP connectors requires the Admin account type or the Manage MCP connectors permission. Each agent belongs to a single workbook.
What it can do
- Answer questions grounded in the data sources you added.
- Run workbook actions, such as inserting rows into input tables, setting control values, or sending notifications to Slack, Teams, or email. Input table writes land in your warehouse.
- Take action in other systems, three ways:
- API actions call third-party APIs through API connectors your admin sets up, so an agent can create a record, kick off a workflow, or pull fresh data from another system.
- Stored procedures run logic that already lives in your warehouse, on Snowflake, Databricks, BigQuery, Redshift, or PostgreSQL. The agent can fill in the arguments from the conversation and use the result in its next step.
- MCP connectors pull context from, or take action in, tools like Jira, Slack, and SharePoint.
- Get human input. Some actions prompt the user to approve or skip before the agent runs them.
- Call Cortex Agents or Genie Agents as tools, including warehouse agents from more than one platform in a single Sigma Agent.
Where people use it
An agent built once runs in several places, with the same instructions, data sources, tools, and permissions everywhere. Some of those places are inside Sigma:
- In a chat element inside a workbook or Sigma app. Users can resume past conversations through chat history, which an admin turns on.
- On a schedule. (existing bullet, unchanged)
Others are headless: the agent does the work, but the interface lives somewhere else.
- Embedded in your own product. With Sigma’s secure embedding, the agent’s chat can sit inside a customer-facing app or internal portal.
- From your own code through the Sigma REST API, as a step in an automation, a data pipeline, or a custom app, returning output that downstream tools can use.
- From AI assistants such as Claude, ChatGPT, Cursor, and Snowflake CoWork or CoCo, through the Sigma MCP server. Users need the Use Sigma MCP with OAuth permission.
Headless doesn’t mean ungoverned. Whether someone calls the agent from Claude or from an embedded app, it still answers from your Sigma data models and runs with that person’s permissions. For a hands-on walkthrough, see Sigma’s webinar Building Headless Sigma Agent Experiences with Claude.
Security
- An agent runs with the permissions of whoever chats with it, calls it, or schedules it. It can only reach data and tools that person can already use.
- Row-level security on the connection and Sigma’s document and feature permissions both apply.
- One nuance for Snowflake shops: when a Sigma Agent calls a Cortex Agent, the Cortex Agent reads Snowflake directly, so Sigma-level restrictions don’t carry through. Snowflake’s roles do, which is why we recommend OAuth so each user’s own role applies.
- Sigma’s October 2 release added beta support for query variables on Snowflake connections. Sigma sets session attributes on every Cortex Agent interaction, so Snowflake row access policies are enforced.
- Chat history can be stored by Sigma or in your own bucket through an external storage integration.
Cost and administration
- Sigma Agents are a premium feature on your Sigma agreement.
- Model usage runs through the AI provider your admin configures: a warehouse-hosted model (Snowflake, Databricks, or BigQuery) or an external provider (OpenAI, Azure OpenAI, Gemini, Anthropic, or Amazon Bedrock). Sigma picks the model for each provider, except Azure OpenAI.
- Actions an agent triggers can use Sigma credits as billable usage events, such as input table writes and API calls.
- Warehouse agents use your data platform’s AI, so their token spend is billed and tracked in Snowflake or Databricks, not in Sigma.
- Admins get an agent management page listing every agent with its owner, token usage, data sources, access, feedback, and an execution log. The AI usage dashboard breaks token use down by agent, user, and model.
Where Sigma Assistant fits
Sigma Assistant is the AI built into the Sigma platform. Unlike a Sigma Agent, there’s nothing to design. An admin configures an AI provider, and users with the Use Assistant permission can start working with it. It has two jobs:
- Build. In a workbook draft, Assistant creates and edits dashboards and apps from plain-language prompts, including charts, tables, controls, filters, actions, and input tables. Plan mode outlines the approach first without changing anything. You can attach data sources, such as data models and semantic views, or a screenshot of a design to recreate. When you build from a data model, Assistant reuses its metrics, so numbers match your governed definitions.
- Analyze. In a published workbook, users ask questions about the workbook’s data, ask follow-ups, and review the step-by-step logic behind each answer. It only uses data on the workbook’s visible pages.
Assistant inherits each user’s permissions, so it can only use data and complete tasks that person already could. It can change filters and controls in a workbook, but not filters applied at the data source, such as row-level security in a data model. Building also requires the Create, edit, and publish workbooks permission and Can edit access to the workbook.
Assistant can also chat with Cortex Agents. From Sigma Home, users can open Assistant and pick a Cortex Agent they have access to, once an admin turns on warehouse agents in AI settings. This capability is currently in beta.
The simplest way to think about the split: Assistant helps anyone analyze and build in Sigma, while a Sigma Agent is a purpose-built worker you design for a specific job.
Part 2: Snowflake agents (Cortex Agents and CoWork)
What it is
Cortex Agents is Snowflake’s fully managed platform for building and running agents inside Snowflake. Snowflake operates the orchestration loop, runtime, and sandbox, so your team only defines the agent. CoWork is the business-facing app at ai.snowflake.com where knowledge workers use those agents.
How you build one
A Cortex Agent is a schema-level object that bundles a model, tools, orchestration settings, and instructions. You create it in Snowsight, with SQL, or through the REST API, then test it in the Snowsight playground. You can pick the model yourself or choose auto, which Snowflake recommends.
For structured data, the agent writes SQL through Cortex Analyst using a semantic view. In practice, that makes a well-built semantic layer the main prerequisite for good answers.
What it can do
Each request runs a loop: plan the work, call tools, then reflect on the results before answering or calling another tool. Available tools include:
- Cortex Analyst for SQL over structured data, and Cortex Search for unstructured data such as documents.
- Code execution, which runs Python in an isolated sandbox, and Data to Chart for visualizations.
- Custom tools built from stored procedures and UDFs, plus packaged agent skills.
- MCP connectors to systems like Jira and Salesforce, and web search.
- Agent toolsets, which let one agent reuse another agent’s tools.
Threads keep conversation context across turns, so client apps don’t have to manage state.
Where people use it
- In CoWork, on the web or the iOS app. Users ask questions and get cited answers, run Deep Research reports, save charts and conversations as shareable Artifacts, and act in Slack, Gmail, Jira, and Salesforce through MCP.
- In your own applications, through the agent:run REST API.
- In CoCo, where developers can work with agents while they build.
Security
- Access runs on Snowflake privileges. Callers need the SNOWFLAKE.CORTEX_USER or SNOWFLAKE.CORTEX_AGENT_USER database role, privileges on the agent, and privileges on the objects each tool uses.
- Cortex Agents takes session permissions from the calling user’s default role. Test this early if your users switch roles.
- CoWork applies existing access controls, row-level policies, and data masking to every interaction, and supports SCIM provisioning through Okta or Microsoft Entra ID.
- Most tools run entirely inside Snowflake. Web search and MCP connectors send requests over the public internet.
Cost
- Usage bills through Snowflake consumption, at the rates in Snowflake’s Service Consumption Table.
- Orchestration and Cortex Analyst are charged per token. Cortex Search is charged by index size and how long it persists. Custom tools add warehouse compute.
- Code execution, web search, MCP connectors, and skills can add cost on top of orchestration.
- Controls include an orchestration budget per run, resource budgets per agent, and per-user quotas.
Where CoCo fits
CoCo, formerly Cortex Code, is Snowflake’s AI coding agent. It runs in Snowsight, a desktop app, a CLI, and extensions for tools like VS Code and Claude Code. It reads your catalog, lineage, and access policies, then generates SQL, pipelines, ML workflows, apps, and agents. It bills on token consumption.
Think of CoCo as a builder’s tool. It can help an engineer stand up a semantic view or a Cortex Agent faster, but it isn’t the agent your business users talk to. It can also call Sigma Agents through the Sigma MCP server.
Part 3: What each does best, and when to use each
The short version: Sigma Agents are strongest where business work happens on top of data. Cortex Agents are strongest as governed building blocks inside Snowflake. Many teams will end up using both.
How the two lineups line up
| Job | Sigma | Snowflake |
|---|---|---|
| Build a custom agent with its own data, tools, and instructions | Sigma Agents | Cortex Agents |
| Ask questions of your data in plain language | Sigma Assistant (analyze) | CoWork |
| Have AI build things for you | Sigma Assistant (build) | CoCo |
The pairs aren’t exact matches. CoWork is a standalone app that works across your data and tools, while Assistant in analyze mode works within the workbook you’re in. CoCo writes SQL and pipeline code in Snowflake, while Assistant in build mode builds Sigma dashboards and apps.
It’s also worth saying that plenty of everyday requests don’t need a custom agent at all. If someone just wants to ask questions about an existing dashboard, Assistant already does that.
Where Sigma Agents excel
- The agent belongs inside a workflow. It lives in the dashboard or data app where people already make the decision, next to the data and the actions they use.
- Business teams own it. Analysts and app builders can create and maintain agents in the workbook without writing code.
- The job ends in a write or an action. Input table writes, action sequences, and MCP actions turn an answer into a finished task, with a human approving when it matters.
- Your data spans platforms. One Sigma Agent can call Cortex Agents and Databricks Genie Agents side by side.
- One agent needs many front doors. The same agent serves a chat element, a schedule, the REST API, and AI assistants through the Sigma MCP server.
- Admins want one place to see agent usage, with owners, token use, and execution logs.
Where Snowflake agents excel
- Engineers own the agent as a governed, reusable Snowflake object, created in Snowsight, SQL, or the REST API.
- The answer lives in documents. Cortex Search is built for unstructured data like contracts, tickets, and transcripts.
- Logic lives in Snowflake code. Custom tools wrap stored procedures and UDFs, and the code execution tool runs Python in a sandbox.
- You want one assistant for every employee. CoWork gives knowledge workers a single place to ask questions and act, rather than an agent tied to a specific app.
- You want direct control over the model and spend, from picking the model to per-run budgets and per-user quotas.
Use both when
Your data team has already built a Cortex Agent on top of semantic views and search services, and a business team needs a workflow around it. Add the Cortex Agent as a Warehouse tool inside a Sigma Agent, and let Sigma handle the app, the approval, the write back, and the Slack message. Each team works in the tool it knows, and nobody rebuilds the semantic layer twice.
Quick decision guide
| If your situation is… | Lean toward | Why |
|---|---|---|
| Business users need an agent inside a dashboard or data app | Sigma Agents | The agent sits next to the data and actions they already use |
| The agent must update records or write results back | Sigma Agents | Input tables and actions write to the warehouse, with approval steps |
| Data spans Snowflake and Databricks | Sigma Agents | One agent can call Cortex Agents and Genie Agents |
| You need the same agent in an app, on a schedule, and in Claude or ChatGPT | Sigma Agents | Chat element, scheduled actions, REST API, and the Sigma MCP server |
| Someone wants to ask questions about an existing dashboard | Sigma Assistant (analyze) | It’s built into the workbook, with no agent to design |
| An analyst wants a dashboard or app built from a prompt | Sigma Assistant (build) | It builds workbook content on your governed data and data model metrics |
| Most answers come from contracts, tickets, or other documents | Cortex Agents | Cortex Search is built for unstructured data |
| Engineers want agents managed as Snowflake objects | Cortex Agents | Agents are schema-level objects you can create with SQL |
| You want one general assistant for every employee | CoWork | A personal work agent at ai.snowflake.com |
| You have a Cortex Agent and need a business workflow around it | Both | Add it as a Warehouse tool in a Sigma Agent |
| A developer needs help writing SQL, pipelines, or semantic views | CoCo | A coding agent for builders, not an end-user agent |
What this looks like in practice
Picture a regional distributor running on Snowflake. Its data team has a semantic view over inventory and orders, and a Cortex Search service over supplier contracts. The operations team wants help with one recurring job: catching low stock early and getting replacement orders placed.
Here’s how we’d lay it out:
- An engineer uses CoCo to speed up building the semantic view and the contract search service.
- The data team builds a Cortex Agent that answers questions about lead times and minimum order quantities from the contracts and order history.
- Operations builds a Sigma Agent inside a replenishment app. Its data sources are the inventory data model, and its tools are that Cortex Agent plus actions that write to a proposed orders input table and send a Slack notification.
- Every morning, a scheduled action sequence calls the Sigma Agent. It checks which items fell below threshold, asks the Cortex Agent about supplier terms, writes proposed orders to the input table, and posts a summary to the buyers’ Slack channel.
- Buyers open the app’s chat element to review the proposals, ask follow-up questions, and approve changes before the agent writes them.
- Leadership uses CoWork for broader questions, like how supplier performance is trending this quarter.
Each product does the job it’s best at. Snowflake holds the governed logic and document search. Sigma turns it into a daily workflow that ends in an action, and CoWork serves the open-ended questions.
The bottom line
Sigma Agents and Snowflake’s agents aren’t competing for the same job. Cortex Agents give your data team governed building blocks inside Snowflake, and CoWork puts a general assistant in front of every employee. Sigma Agents turn your data, and those building blocks, into agents that live inside the apps where work happens and act on what they find.
For most Snowflake customers using Sigma, the real question isn’t which one to pick. It’s which layer each agent belongs in.
If you’re working through that decision, we can help. Maverick Data is a Sigma implementation partner, and we help teams design, build, and govern agents on Sigma and Snowflake. Reach out to spencer@maverickdata.io if you want to talk more about this topic!



