For AI agents: a documentation index is available at the root level at /llms.txt and /llms-full.txt. Append /llms.txt to any URL for a page-level index, or .md for the markdown version of any page.
Sign inTry it free
DocsGuidesSDKsIntegrationsAPI docsTutorialsFlagship blog
DocsGuidesSDKsIntegrationsAPI docsTutorialsFlagship blog
  • Get started
    • Overview
    • Onboarding
    • Get started
    • Launch Insights
    • LaunchDarkly architecture
    • LaunchDarkly vocabulary
  • AgentControl
    • AgentControl
      • Quickstart for AgentControl
    • Manage AgentControl
  • Feature flags
    • Create flags
    • Target with flags
    • Flag templates
    • Manage flags
    • Code references
    • Contexts
    • Segments
  • Releases
    • Releasing features with LaunchDarkly
    • Release policies
    • Percentage rollouts
    • Progressive rollouts
    • Guarded rollouts
    • Feature monitoring
    • Release pipelines
    • Engineering insights
    • Release management tools
    • Applications and app versions
    • Change history
    • Restoring previous flag versions
  • Observability
    • Observability
    • Session replay
    • Error monitoring
    • Logs
    • Traces
    • Observability metrics
    • Product analytics events
    • LLM observability
    • Alerts
    • Dashboards
    • Service map
    • Vega for auto-remediation
    • Observability MCP server
    • Search specification
    • Observability settings
    • Observability integrations
  • Experimentation
    • Experimentation
    • Experiment metric types
    • Experiment configuration
    • Managing experiments
    • Analyzing experiments
    • Multi-armed bandits
    • Holdouts
  • Metrics and events
    • Metrics in LaunchDarkly
    • Creating metrics
    • Metric groups
    • Events
    • Autogenerated metrics
  • Warehouse native
    • Warehouse native metrics
    • Setting up external warehouses
    • Creating experiments using warehouse native metrics
  • Infrastructure
    • Connect apps and services to LaunchDarkly
    • LaunchDarkly in China and Pakistan
    • LaunchDarkly in the European Union (EU)
    • LaunchDarkly in federal environments
    • Public IP list
  • Your account
    • Projects
    • Views
    • Environments
    • Tags
    • Teams
    • Members
    • Roles
    • Account security
    • Feature previews
    • Billing and usage
    • Changelog
Sign inTry it free
LogoLogo
On this page
  • Overview
  • Choose a configuration mode
  • How AgentControl works
  • Additional resources
  • Set up AgentControl configs
  • Config evaluations
  • Agents
  • Deliver and monitor configs
  • Manage AgentControl configs
AgentControl

AgentControl

Was this page helpful?
Previous

Quickstart for AgentControl

Next
Built with

Overview

The topics in this category explain how to use LaunchDarkly AgentControl to manage your configs. You can use AgentControl to customize, test, and roll out new large language models (LLMs) in your generative AI applications.

An AgentControl config is a single resource that you create in LaunchDarkly to control how your application uses large language models. It lets teams manage prompts, instructions, and model settings outside of application code so they can iterate, experiment, and release changes more safely without redeploying. To learn how to create one, read Create configs.

Choose a configuration mode

When you create a config, you select a configuration mode that defines how the model behaves in your application.

AgentControl supports two modes:

  • Completion mode: Configure prompts using messages and roles for single-step model responses. You can attach judges to completion-mode config variations in the LaunchDarkly UI. To learn more, read Create and manage config variations.
  • Agent mode: Configure multi-step workflows using structured instructions. For agent-based variations, invoke a judge programmatically using the AI SDK. Agent mode does not create a separate resource. To learn more, read Agents.

Both modes use the same config resource and support variations, targeting rules, monitoring, experimentation, and lifecycle management.

Both completion mode and agent mode can integrate with external tools or APIs. Tool usage depends on how your application and SDK are implemented, not on the selected configuration mode. Agent mode enables structured, multi-step workflows. You can integrate external tools in either mode.

With AgentControl, you can:

  • Manage model configuration outside of your application code so you can update prompts and settings at runtime without deploying changes.
  • Upgrade to new model versions and roll out changes gradually and safely.
  • Add new model providers and progressively shift production traffic between them.
  • Compare variations to determine which performs better based on cost, latency, satisfaction, or other metrics.
  • Run experiments to measure the impact of generative AI features on end-user behavior.

AgentControl supports advanced use cases such as retrieval-augmented generation, integration with external tools or APIs, and evaluation in production. You can:

  • Track which knowledge base or vector index is active for a given model or audience.
  • Experiment with different chunking strategies, retrieval sources, or prompt and instruction structures.
  • Evaluate outputs using side-by-side comparisons or online evaluations with judges in completion mode, or invoke a judge programmatically using the AI SDK for other variations.
  • Build guardrails into runtime configuration using targeting rules to block risky generations or switch to fallback behavior.
  • Apply different safety filters by user type, geography, or application context.
  • Use live metrics, including satisfaction and quality signals you define, to guide rollouts.

These capabilities let you evaluate model behavior in production, run targeted experiments, and adopt new models safely without being locked into a single provider or manual workflow.

If you use an AI agent to create and manage configs, you can use LaunchDarkly agent skills to help AI coding agents execute common tasks safely and consistently.

Availability

AgentControl is an add-on feature. Access depends on your organization’s LaunchDarkly plan. If AgentControl does not appear in your project, your organization may not have access to it.

To enable AgentControl for your organization, contact your LaunchDarkly account team. They can confirm eligibility and assist with activation.

For information about pricing, visit the LaunchDarkly pricing page or contact your LaunchDarkly account team.

How AgentControl works

Every config contains one or more variations. Each variation defines model settings with messages for completion mode or instructions for agent mode. You define targeting rules to control which variation LaunchDarkly serves to a given context.

In your application, you use one of LaunchDarkly’s AI SDKs to evaluate a config for a given context. The LaunchDarkly SDK evaluates targeting rules and selects a variation. The AI SDK plug-in then uses that variation to return the resolved configuration, including model settings and messages or instructions.

As part of this evaluation, the AI SDK resolves any variables in your prompts using context attributes and additional variables you provide. This enables you to tailor prompts and model settings for each context at runtime. When you update prompts, instructions, or model configuration in LaunchDarkly, those changes take effect immediately without requiring you to redeploy your application.

LaunchDarkly does not invoke model providers on your behalf. Your application is responsible for calling the model provider directly using its own credentials and the configuration returned by the AI SDK. LaunchDarkly does not proxy or independently invoke model providers.

After your application calls the model provider, use the AI SDK to track AI metrics such as generation count, token usage, latency, errors, and evaluation scores. LaunchDarkly aggregates these metrics and displays them on the Monitoring tab.

The topics in this category explain how to create configs and variations, update targeting rules, monitor related metrics, and incorporate AgentControl into your application.

Additional resources

In this section:

Set up AgentControl configs

  • Quickstart for AgentControl
  • Create configs
  • Create and manage config variations
  • Create and manage AI model configurations
  • Tools
  • Prompt snippets

Config evaluations

  • Playgrounds
  • Offline evaluations
  • Datasets
  • Online evaluations
  • Judges
  • Run experiments with AgentControl

Agents

  • Agents
  • Agent graphs

Deliver and monitor configs

  • Config targeting
  • Monitor config performance
  • Understand AI impact with AI Insights
  • Manually instrument LLM spans

Manage AgentControl configs

  • Manage AgentControl configs
  • Compare config variation versions
  • AgentControl and information privacy

In our guides:

  • Managing AI model configuration outside of code
  • Using targeting to manage AI model usage by tier

In our SDK documentation:

  • .NET AI SDK reference
  • Go AI SDK reference
  • Node.js (server-side) AI SDK reference
  • Python AI SDK reference
  • Ruby AI SDK reference