The agentic era is moving from research papers to production data platforms. With the general availability of the Cortex Coding Agent, Snowflake is making a clear statement: agentic workflows are now a core primitive for working with data at scale. This isn't about slightly better SQL autocomplete; it's about fundamentally changing how developers build data applications by composing data-aware AI skills.
what just shipped
In its latest release, Snowflake moved its Cortex Agents Coding Agent to general availability. This means the tool is now fully supported for production use. Alongside the agent itself, the release also includes general availability for using Cortex Extension references within agent skills. These components work together to let developers create and deploy customized, AI-powered assistants that have deep context of their organization's data environment.
Unlike a generic, standalone coding assistant, a platform-native agent operates with inherent knowledge of your data schemas, governance policies, and available services within Snowflake. The goal is not just to write code faster, but to automate entire data-centric tasks by expressing intent rather than explicit instructions.
composing agents with skills and extensions
The real leverage here comes from the composability of the agent framework. The release notes highlight two key concepts: skills and extensions. An extension can be thought of as a tool the agent can use—a connection to an internal API, a proprietary data transformation function, or a call to another service. A skill is the agent's ability to use that tool to accomplish a specific task, often guided by a prompt that instructs the agent on how and when to use it.
This creates a powerful paradigm where you are not just prompting an LLM, but equipping it with a specific, curated set of capabilities. You move from being a prompt engineer to an agent builder. Instead of writing a complex Python script for a recurring analytics task, you might define a skill that allows the agent to perform that task on demand.
A hypothetical definition might look something like this, using SQL DDL to configure an agent:
-- Hypothetical DDL for agent creation
CREATE OR REPLACE CORTEX AGENT financial_analyst_agent
WITH SKILLS (
-- Skill to generate a quarterly sales report
( NAME = 'generate_quarterly_report',
PROMPT = 'Given a quarter and year, use the get_sales_data_udf function to retrieve sales data and summarize it by product category. Format the output as a markdown table.',
EXTENSION = 'get_sales_data_udf'
),
-- Skill to perform fraud detection
( NAME = 'check_transaction_fraud',
PROMPT = 'For the given transaction ID, use the fraud_detection_model_api to score the transaction for fraud risk. Return the risk score and a confidence level.',
EXTENSION = 'fraud_detection_model_api'
)
);
This declarative approach allows you to build complex, multi-step logic that is both auditable and integrated directly with the platform's governance and security models.
the shift to intent-based development
Making a coding agent generally available signals a durable trend. The primary interface for data interaction is moving up a layer of abstraction, from writing explicit SQL and Python to declaring intent and composing agentic capabilities. For developers, this means the focus of our work begins to shift.
Instead of writing and maintaining thousands of lines of boilerplate for data pipelines, the high-value work becomes designing robust, reliable agent skills and extensions. The challenge is no longer just about optimizing a query, but about clearly defining the boundaries and capabilities of an autonomous agent that can write and execute its own queries.
Of course, this introduces new complexities. Cost management, agent observability, and security guardrails are critical. When an agent can autonomously chain together function calls, clear monitoring and per-user quotas become essential for production stability. But the potential for leverage is immense. You are no longer just building a dashboard; you are building a virtual data analyst that your entire organization can interact with.
so what
The GA of a platform-native coding agent is a significant milestone. It moves agents from a niche, experimental tool to a production-ready component of the modern data stack. As a builder, this is a new primitive to master. It's time to start thinking less about writing individual scripts and more about building systems of agents that can reason about and act upon your organization's data.
Top comments (1)
Interesting direction from Snowflake. I agree that the bigger shift isn’t “better Copilot,” but giving the agent access to governed data and real tools.
The part I’d be watching closely is the boundary between a skill being capable and being safe to run autonomously. Once an agent can query data, call extensions, and chain multiple actions, permissions, cost limits, audit logs, and deterministic validation become just as important as the model itself.
I also think observability will become a major differentiator here. It’s not enough to know that an agent produced the right answer — you want to know which tools it called, what queries it generated, how much data it touched, and why it took a particular path.
The “intent-based development” idea is definitely where things are heading. The interesting engineering problem now is designing the guardrails around that abstraction.
Would be curious to hear how others are approaching production evaluation for these kinds of data agents.