Delivering adaptive AI with LaunchDarkly and Snowflake Cortex

LLMs are powerful tools, but they’re hard to control in production. A model that performs well in testing might behave differently when it encounters real users. Prompt changes can introduce unexpected regressions, and even minor updates often require a complete deployment cycle.

If you're building AI-powered experiences, like chatbots, copilots, or decision helpers, you probably need a better delivery model. Ideally, one that supports personalization, iteration, and safety without adding operational overhead.

Why personalization creates complexity

The best AI experiences are context-aware. A support bot should respond differently to a first-time user than it does to a paying customer. An internal assistant might shift the tone or route questions differently depending on the user’s department or role.

That logic lives in prompts, parameters, and model choices. But when these decisions are baked into code or spread across tools, they become difficult to manage; you lose the ability to test them safely, and it’s challenging to track who saw what. Furthermore, when things go wrong, rolling back requires another deployment. In cases like this, runtime control is critical. Personalization should be an asset, not a risk factor.

Defining, updating, and routing AI logic in production

Snowflake Cortex and LaunchDarkly offer a shared solution for running and delivering AI responsibly. Cortex provides access to top-tier models inside your Snowflake environment, allowing you to use GPT, Claude, Mistral, and others, secured within the data systems your team already manages.

LaunchDarkly handles how those models get used in production. You can define AI behavior, including prompts, fallback logic, and model routing, outside of your codebase. This lets your team update behavior in real time, target changes to specific users, and respond quickly when something breaks.

This lets your team update behavior in real time, target changes to specific users, and respond quickly when something breaks. You can also stream LaunchDarkly evaluation events into Snowflake tables, then join them with model latency and cost data to monitor how each configuration performs and what it costs.

This integration decouples AI logic from deployments. It gives you the tools to treat prompts and models like feature flags, making them configurable, observable, and reversible at runtime.

See LaunchDarkly and Cortex in action

Here’s what that looks like in code. This snippet fetches a live AI Config from LaunchDarkly and uses it to call the Snowflake Cortex Completion API:

const config = await aiClient.config(
  process.env.LAUNCHDARKLY_AI_CONFIG_KEY,
  userContext,
  {},
  { userInput }
);

const response = await fetch('https://<snowflake-api>', {
  method: 'POST',
  headers: { Authorization: `Bearer ${token}` },
  body: JSON.stringify({
    model: config.model.name,
    messages: config.messages,
    stream: false
  })
});

This setup allows prompts and models to be configured without code changes. You can switch models, edit prompt templates, or add dynamic fallback logic—all from the LaunchDarkly UI or SDK.

Where LaunchDarkly fits into the AI delivery model

Even well-tested AI features can fail under real-world conditions. LaunchDarkly AI Configs help you respond quickly to unexpected behavior in your app. You can turn off a variation with a kill switch, redirect traffic to a safer model, or roll back to a previous version. These changes take effect instantly, without requiring a deployment. Each config is tracked and versioned, and you receive logs of what was served, when, and to whom. Because inference runs inside Snowflake, prompts and results stay within your governed environment, ensuring your data remains fully under your control. If you're measuring performance or cost per response, you can tie metrics back to the exact config used.

Building a support agent: a real-world example

Say you're building an AI-powered support agent for an e-commerce platform. You want it to provide basic order updates, handle returns, and offer product recommendations based on purchase history.

You might start with a general-purpose model for order tracking, then switch to a more advanced model for returns. You could experiment with tone based on loyalty tier or user sentiment; you might also introduce a recommendation system that adapts to region, inventory, or user behavior.

Using Snowflake Cortex and LaunchDarkly, you can make all of these decisions configurable. Your support agent adapts to each user while giving your team full visibility and control. If a change performs poorly, you can roll it back; if a new prompt improves conversion, you can expand it. This setup helps you deliver intelligent, personalized AI while protecting the reliability of your app.

Take control of AI in production

Your standards for delivering AI should match the standards you already apply to production software. You need a feedback loop, runtime visibility, and safety controls. Snowflake Cortex offers model flexibility and secure access to your data, while LaunchDarkly provides the delivery controls to ship more safely, iterate quickly, and respond to real-world behavior. Used together, they create a foundation for adaptive, production-ready AI.

Learn more about AI runtime control: