Oct 19, 2026/4 min readAI & ML
Introducing Snowflake Decision Fast: Structured Decisions at the Speed of Business
Just two weeks ago, we introduced Snowflake Decision in Cortex AI Functions in private preview. Built specifically for classification, scoring, filtering and routing, it tackles high-volume tasks with bounded answers. Instead of open-ended text, it returns a typed answer, such as a specific category, a numerical score or a yes/no probability, that your workflow can act on directly.
Our customers quickly highlighted the need for “arcade speed” for decisions sitting inside interactive or latency-sensitive workflows, such as live routing steps, real-time fraud checks or an agent's first triage hop. In these environments, speed is critical.
Today, in private preview, we are expanding the Snowflake Decision offerings to address these needs with the following capabilities, all backed by the same governance, access controls and audit policies you already rely on:
snowflake-decision-fast: A lower-latency variant of snowflake-decision built for workloads where response time matters just as much as decision quality.
REST API support: Call Snowflake Decision models through Cortex AI Gateway, allowing applications, services and agents outside of SQL to use structured decision-making.
Cortex AI Functions: snowflake-decision-fast is natively available through AI_COMPLETE in SQL.
Seeing decisions in motion: Real-time text classification
To demonstrate the interactive power of snowflake-decision-fast, we built a real-time text classification application. As a customer types a support ticket, such as a complaint about being charged twice, the application quickly evaluates the live text to make three simultaneous decisions: routing the ticket to the right team, flagging urgency and reading the customer's sentiment.
On every keystroke, the interactive application evaluates the current text state and asks the model bounded questions to determine the next workflow step. This interactive capability can be executed externally via the Cortex AI Gateway:
import os
from typesafe_sdk import Choice, Noul, Score, TypeSafeClient
client = TypeSafeClient(
api_key=os.environ["SNOWFLAKE_PAT"],
base_url="https://<your-gateway-host>/api/v2/aigateways/<GATEWAY_NAME>",
model="snowflake-decision-fast",
)
response = client.system_one(
state=(
"hi i have a question about my account. i was charged twice for my "
"subscription and would like a refund. i need this resolved today "
"before our finance 5pm cutoff. this is the 3rd time i contacted support."
),
questions={
"needs_attention_now": Noul(
instructions="Does this ticket need attention now because it is urgent or time-sensitive?"
),
"team": Choice(
instructions="Which support team should handle this ticket?",
criteria={
"billing": "Payments, invoices, subscriptions, duplicate charges, refunds.",
"technical_support": "Product bugs, outages, broken integrations, API issues.",
"account_access": "Login, password, MFA, locked account, authentication.",
"sales": "Pricing, plan upgrades, renewals, contracts, purchasing.",
"general": "Unclear, mixed, or uncategorized requests.",
},
),
"customer_tone": Score(
instructions="How frustrated does the customer sound? This is about tone, not issue severity.",
criteria=["Calm", "Frustrated", "Very frustrated"],
),
},
)
print(response.nouls["needs_attention_now"].noul)
print(response.choices["team"].choice)
print(response.choices["team"].probabilities)
print(response.scores["customer_tone"].score) # 0=Calm, 1=Frustrated, 2=Very frustrated
Here it is in action:
Figure 1: With our text classification tool, you can create a support ticket, and snowflake-decision-fast makes three decisions at once, in real time: who should handle it, how urgent it is, and how the customer feels.
This interactive use case highlights the core mechanics of decision models:
Construction bounds: The app offers only valid moves as choice options. The model cannot return an invalid action, removing the need for parsers, retry loops or complex error handling in your code.
Probabilities as the product: The model returns the chosen value and per-option probabilities rather than free-text reasoning. A highly confident 0.99 for a "Billing" route provides a definitive signal you can threshold on for live workflows.
Visible latency: The live interface relies on near-instant decisions as the user types, with endpoint round trips consistently completing in under 300 ms. Running on snowflake-decision-fast ensures that the latency remains low enough to provide a seamless, real-time user experience.
Scaling to massive table operations
While the REST API is ideal for single-shot, interactive decisions, the same structured decision-making capabilities are also available through Cortex AI Functions, enabling developers to apply classification and routing logic directly to large data sets using simple SQL.
Consider a global support platform that needs to triage and route millions of incoming tickets or messages every day. Using a general-purpose LLM for a narrowly defined classification task can introduce unnecessary complexity, cost and processing overhead, particularly when each record requires only a small set of structured decisions.
By using snowflake-decision-fast in AI_COMPLETE, teams can apply the same decision logic across entire tables without building separate inference pipelines or managing external API integrations.
For example, the following query classifies incoming support tickets by routing queue and determines whether each ticket requires escalation, returning structured outputs ready for downstream processing:
SELECT
ticket_id,
AI_COMPLETE(
model => 'snowflake-decision-fast',
prompt => TO_JSON({
'state': ticket_body,
'questions': {
'routing_queue': {
'type': 'choice',
'instructions': 'Determine the correct support queue for this ticket.',
'criteria': {
'billing': 'Invoices, payments, or subscription changes',
'technical': 'System errors, bugs, or API issues',
'account': 'Password resets or profile updates'
}
},
'requires_escalation': {
'type': 'noul',
'instructions': 'The customer is expressing extreme frustration or threatening to churn'
}
}
})
)::VARIANT AS decision_output
FROM incoming_support_tickets_10m;
What works for a real-time REST API call scales to high-volume classification, offline scoring and asynchronous triage directly within your data pipelines.
Speed at quality you can trust
The landscape of structured AI decision-making is evolving rapidly, and we are iterating quickly to improve both the quality and the raw execution speed of our models. Our engineering focus is to aggressively push the frontier of decision accuracy on established benchmarks while simultaneously driving down latency and compute costs for real-time applications.
snowflake-decision-fast is our latest step in giving developers the exact performance profile their architecture demands, and you can expect rapid, ongoing updates to model quality in the coming months.
Figure 2: The average accuracy and time to process table rows. The difference between snowflake-decision and snowflake-decision-fast is calculated using our internal decision benchmark.
Getting started
To request early access to the decision models, reach out to your Snowflake account team. A representative will follow up with next steps, including comprehensive private preview documentation.
Fast, structured decisions open up patterns that weren't practical before: agents that check each step before acting, pipelines that score every record as it lands and live workflows that route in real time. The question shifts from "Can we afford to put AI here?" to "Where else could a decision go?"
