Video Summary - Snowflake Discover AI

Day 1 Theme: Accelerate development with Snowflake Cortex Code (Coco)

This video is a Snowflake Discover AI Day 1 event focused on how Cortex Code / Coco helps teams move from idea to production faster using:

Live Snowflake context
Built-in security and governance
Persona-based workflows

Across sessions, the emphasis is that the “big change” is moving from autocomplete-style coding to delegating real workflow tasks to an agent—under governance.

Key technological concepts & product features highlighted

1) “Agentic enterprise” approach (execution over prototypes)

The event frames that AI agents can fail in production if they lack:

Shared context
Governance

Without these, agents may produce conflicts, inconsistent outcomes, and siloed decisions.

Snowflake’s framing is the Agentic Enterprise, built on:

Enterprise data & context (a unified data estate)
An AI model layer (choosing models without lock-in)
Software/apps connected to business systems
An agentic control plane (“mission control” for governed agents)

2) Coco as a native AI coding agent for data teams

Coco is positioned as a workflow expert for data engineering—not just generic code generation.

It’s built for governed access by default, aligned with Snowflake’s RBAC model (i.e., no bypassing policies).

Key capabilities emphasized:

Live schema injection: Coco reads the current Snowflake objects (tables/views/policies/relationships) at generation time rather than relying on stale docs.
Expert data engineering skills built in: pre-built workflows and domain knowledge.
Governance enforced by default: RBAC-aware and compliant with security controls.

3) How Coco works internally (“agent harness”)

A conceptual architecture described as an agent harness, including:

Live schema context layer
Agent context layer (project/session context and objects touched)
Environment layer (role, warehouses, database context—affecting governance)
Agent skills (100+ prebuilt domain skills)
Agent runtime (execution loop, tool calls, plan/act cycles executed within Snowflake infrastructure)

4) Benchmarks / evaluation claims (enterprise relevance)

The sessions reference an external benchmark:

AD-Bench (DBT team’s Analytics & Data Engineering benchmark)

Coco is claimed to perform strongly versus other coding agents, including:

~51% fewer tokens to achieve similar data engineering outcomes (improved cost + latency).

5) Coco “surfaces” (where you can use it)

Coco is demonstrated across multiple interaction points:

CLI
Snowflake Snowsite (web UI inside Snowflake)
VS Code extension
Coco Desktop (native VS Code-based app on Windows/Mac)

Additional surfaces mentioned/announced:

Coco Desktop: app builder + governed desktop workflows
Coco for mobile (iOS/Android announced; public preview soon)
Coco Slackbot

6) Skills as reusable “agent components”

“Skills” are treated as repeatable, controlled IP:

shareable and controlled
reusable across surfaces and agents

Skills can represent reusable tasks such as lineage, governance checks, and generating DBT/DCM artifacts.

7) Extensibility and standards

The event highlights extensibility, including:

MCP (Model Context Protocol) support/mentions
An “agent context protocol/ACP” concept
Coco Agent SDK (announced) for building custom agents/solutions while retaining Coco benefits like skills, live schema, and governance

Demos and tutorials described

Demo set A: Building an end-to-end data engineering pipeline with Coco

Presenter: Chongju (Chongju Chong), Solution Engineering leader

Goal: demonstrate automation for a bronze → silver → gold-style pipeline.

Coco orchestrates:

Ingestion from S3 to Snowflake bronze (S3 integration + Snowpipe)
CDC/changes triggering downstream transformations
DBT project deployment for silver/gold models
Task-based orchestration using Snowflake Tasks (and possibly stored procedures)
Data quality and verification gates, including DBT tests and quality checks

DCM (Data Change Management) Project (public preview):

declarative “define statements”
plan/deploy with change history
infrastructure-as-code style versioning for data objects

The demo includes:

DCM creating tables with tags, including PI tags
tagging, lineage, run histories
DBT tests and lineage visibility (DAGs)
building a Streamlit governance dashboard from pipeline metrics
a failure/debug loop where Coco detects an error (timestamp/date format) and redeploys the app

Governance questions answered during Q&A

Governance of agent outputs:

Use Cortex AI Guardrails plus custom hooks (pre/post) for workflows
Scope what the agent can access, constrain response behavior, and continuously monitor outputs

Data masking/privacy:

supports row access policies and masking policies
masking can be attached to PI tags and propagated across objects

Business logic / semantic layer integration:

semantic layer is presented as key to generating accurate BI/SQL from natural language
references a later day session: Day 3 “trusted semantic layer”

Demo set B: Developers building an app with Coco (React vs Streamlit)

Presenter: Mukesh Chowi, Senior Solution Engineer

Shows using Coco to generate and deploy a React application (not Streamlit) via Snowark/Container Services.

Example app: Talent Intelligence Portal

Capabilities include:

ingest PDFs (resumes + job descriptions)
parse and store extracted content
dashboards + candidate scoring + comparison views
upload new resumes and have the UI reflect updates

Iteration workflow:

Coco updates the app by adding UI/functionality (e.g., JD selector panel, candidate shortlisting)
local run then deploy to container services
includes smoke tests/validation steps

Q&A clarifications

Streamlit: good for simpler UI/visualization
React: better for complex front-end functionality
semantic models can be imported (e.g., PowerBI/Tableau) using semantic interchange/open standards references

Also emphasized: “Bring code to data”—building inside Snowflake avoids moving enterprise data into separate app stacks.

Demo set C: Data science ML lifecycle with Coco (fraud + revenue forecasting)

Presenter: Barth (Barath Sresh), Senior partner solution engineer

Describes Coco for end-to-end MLOps lifecycle automation:

develop + iterate notebooks
orchestrate training/inference with Snowflake tasks
register models in Model Registry / Feature Store
deploy for batch or real-time inference (via stored procedures, feature store, container services)
monitor and detect drift; alert and retrain/fix
integration with external tools like MLflow

Demo scenario: Fraud detection (classification)

Workflow shown:

synthetic dataset (1M rows, ~3% fraud rate)
EDA + feature engineering with pandas
train/test split
train multiple models (Random Forest, Logistic Regression, XGBoost classifier)
evaluate with accuracy, precision/recall/F1, ROC/AUC, confusion matrix
register the best model to the model registry (versioned artifact, v1)
batch scoring on new data with higher fraud rate (example: ~5%) to induce drift
drift detection via scoring metrics / population index-style metrics
automation using Snowflake stored procedures + tasks for frequent prediction + drift alerts
mention of “self-heal” behavior when notebook execution fails

Demo scenario: Revenue forecasting (regression)

daily revenue prediction across multiple years
notebook generation for EDA and feature engineering (lags)
regression models (examples mentioned: XGB regressor, random forest regressor, “trig regression”)
batch scoring + drift monitoring and alerting

Q&A

Can semantic models be used as context for generating ML code?

Yes: provide the semantic model link/context so Coco generates ML code using business meaning.

Hands-on lab: “Getting started with Snowflake Coco for data analysis”

Presenter: Sho Tanaka (developer advocate, Tokyo)

A beginner-oriented (Level 100) workshop with step-by-step setup:

Create a Snowflake trial account
In Snowflake, activate a quick start environment
Use Snowflake Marketplace public data (weather/finance) via “zero copy” dataset setup
Use Coco in Snowflake worksheets to explore datasets:
- list accessible databases
- weather examples:
  - count stations by country (top 10)
  - list variables + record counts
  - visualize monthly average temperature (line chart)
  - find weeks exceeding thresholds (e.g., >35°C)
- stock example:
  - identify top tickers by volume in recent months
- correlation example:
  - join weekly average temperatures with weekly closing prices (e.g., Exxon)
  - compute Pearson correlation

Notes emphasized:

Coco can generate SQL and Python/Jupyter notebooks
it can attempt error fixing when code fails

Practical takeaways / “guides” explicitly emphasized

Use Coco with live context: prefer live schema injection and governed access over stale documentation.
Scope prompts to reduce agent deviation; use a single comprehensive plan when needed (e.g., the app-building demo).
Use Skills as reusable workflow components across CLI/UI/Desktop surfaces.
For data engineering production readiness:
- Snowflake-native orchestration (Tasks)
- DBT tests
- DCM change management
- PI tagging + masking
For governance:
- combine guardrails + RBAC + masking/tagging + monitoring hooks
For ML:
- use model registry + tasks + drift detection workflows
- Coco can generate notebooks and run end-to-end, including “self-healing” behavior

Main speakers / sources (in order of appearance)

Louis Lee (host; head of product marketing and evangelism, APJ, Snowflake)
Travis Murphy (AI and data evangelist, Snowflake; Sydney)
Chongju Chong (Solution Engineering leader/manager, Snowflake; Australia)
Mukesh Chowi (Senior Solution Engineer, Snowflake)
Barth Sresh (Senior partner solution engineer, Snowflake)
Sho Tanaka (Shosan/Josean in subtitles) (Lead developer advocate, Snowflake; Tokyo)

Snowflake Discover AI | July 6, 2026

Key takeaways