Index of every page on this site: llms.txt
All skills
launchdarkly avatar

/configs-create

@f0ee110 official
Run it yourself

Create and configure configs in LaunchDarkly. Helps you choose between agent vs completion mode, create the config, add variations with models and prompts, and verify the setup.

Use this Skill: https://skilld.dev/gh/launchdarkly/ai-tooling/configs-create

Nothing lands on disk. Nothing to clean up.

Fork this Skill

Edit a local copy. It keeps the author and licence.

SKILL.md

≈48 tokens for metadata: the name and description. ≈3.2k when used: this file. ≈346 more on demand in 1 file.

Description uses 2.4% of example budget

Before choosing a Skill, your Agent reads its name and description. All available Skills share that space.

  • A shorter description leaves more room for other Skills. This entry exceeds our 1% size suggestion.

In our Claude Code example, all Skill names and descriptions share 8,000 characters. This Skill uses ≈194 characters, or 2.4%.

The 1% threshold is a size suggestion. Longer descriptions can still fit.

Your model, settings, and other Skills decide how much text your Agent can read.

Example settings and source

The example uses a 200k-token context and default Claude Code settings. The count includes the name, description, separators, and when_to_use when present. Codex also counts local file paths.

Skit's source and limits: Codex 0.160.1, Claude Code 2.1.292.

Create Config

You're using a skill that will guide you through creating a config in LaunchDarkly. Your job is to understand the use case, choose the right mode, create the config and its variations, and verify everything is set up correctly.

⚠️ This skill creates a config — it does not make it servable. A freshly-created config has its fallthrough pointing at an auto-generated disabled variation, not at the variation you just created. The SDK will return ai_config.enabled=False on every evaluation until you flip targeting on and point the fallthrough at your new variation. This is not a bug — it's the default state. You must run /configs-targeting (or the equivalent REST / CLI call shown in Step 5) before verifying against the SDK, or verification will look like the LD-served path is broken when it isn't. The single most common failure mode users hit with this skill is skipping the targeting step and spending time debugging enabled=False in their application code.

Prerequisites

This skill requires the remotely hosted LaunchDarkly MCP server to be configured in your environment.

Primary MCP tool:

  • create-agent-config with resource: "config" -- create a config with its first variation in one step (recommended): pass variationKey, variationName, modelConfigKey, modelName, and instructions or messages along with the config fields

Alternative MCP calls (for more control):

  • create-agent-config with resource: "config" -- create just the config shell (configKey, name, mode)
  • create-agent-config with resource: "variation" -- add a variation with model, prompts, and parameters
  • get-agent-configs -- verify the config was created correctly

Optional MCP tools (enhance workflow):

  • get-agent-configs -- browse existing configs to understand naming conventions
  • create-project -- create a project if one doesn't exist yet

Important: Bias Towards Action

When the user provides enough context (use case, model, mode), proceed through the entire workflow without stopping to ask for details you can infer. Use reasonable defaults for unspecified fields: default for variation key, the use case as the basis for instructions/messages, kebab-case for config keys. Complete all steps (create + verify) in one pass.

Workflow

Step 1: Understand the Use Case

Before creating, identify what you're building:

  • What framework? LangGraph, LangChain, CrewAI, Strands, OpenAI SDK, Anthropic SDK, custom
  • What does the agent need? Just text generation, or tools/function calling?
  • Agent or completion? See the decision matrix below

Step 2: Choose Agent vs Completion Mode

This choice is about input schema and framework compatibility, not execution behavior. Agent mode returns an instructions string; completion mode returns a messages array. Both provide provider abstraction, A/B testing, and metrics tracking.

Your Need Mode Why
LangGraph, CrewAI, Strands, AutoGen frameworks Agent Frameworks expect goal/instruction input
Persistent instructions across interactions Agent Single instructions string, SDK method: agent_config() (Python) / agentConfig() (Node)
Direct OpenAI/Anthropic API calls Completion Messages array maps directly to provider APIs
Full control of message structure Completion System/user/assistant role-based messages
One-off text generation Completion Standard chat format
Need online evaluations (LLM-as-judge) Completion Online evals are only available in completion mode

Both modes support tools. Not all models support agent mode -- check model compatibility if using agent mode. If unsure, start with completion mode (it's the API default and more flexible).

Step 3: Create the Config (Recommended: One Step)

Use create-agent-config with resource: "config" and the first variation's fields to create both in one call. This is the recommended approach: it handles creation, variation setup, and verification automatically.

Config fields:

  • resource -- "config"
  • configKey -- unique identifier (lowercase, hyphens)
  • name -- the config's human-readable name
  • mode -- "agent" or "completion"
  • Optional: description, tags

Variation fields:

  • variationKey, variationName -- identifiers for the first variation
  • modelConfigKey -- a key from get-ai-model-configs: a global Provider.model-id key (e.g., OpenAI.gpt-4o, Anthropic.claude-sonnet-4-5) or a custom model config's own key
  • modelName -- the model identifier (e.g., gpt-4o). Always pass this in the initial call — leaving it off produces a variation that displays "NO MODEL" and forces a second PATCH to set it. The field is modelName; it is not name or model.name on this endpoint, and name is only ever the config's name.

For agent mode, provide:

  • instructions -- a string with the agent's system instructions

Example agent-mode call:

{
  "projectKey": "my-project", "resource": "config", "configKey": "support-agent", "name": "Support Agent",
  "mode": "agent", "variationKey": "default", "variationName": "Default",
  "modelConfigKey": "OpenAI.gpt-4o", "modelName": "gpt-4o",
  "instructions": "You are a customer support agent. Help users resolve their issues."
}

For completion mode, provide:

  • messages -- an array of {role, content} objects (system, user, assistant)

Example completion-mode call:

{
  "projectKey": "my-project", "resource": "config", "configKey": "product-descriptions", "name": "Product Descriptions",
  "mode": "completion", "variationKey": "default", "variationName": "Default",
  "modelConfigKey": "Anthropic.claude-sonnet-4-5", "modelName": "claude-sonnet-4-5",
  "messages": [
    {"role": "system", "content": "You are a product copywriter. Write compelling descriptions."},
    {"role": "user", "content": "Write a description for: {{product_name}}"}
  ]
}

Optional:

  • parameters -- model parameters like {temperature: 0.7, max_tokens: 2000} (match the UI's snake_case keys)

The tool returns the full verified config detail with the variation attached.

Step 3 (Alternative): Two-Step Creation

If the user asks for more control or a step-by-step approach, use the individual tools:

  1. create-agent-config with resource: "config" and no variationKey -- create the config shell
  2. create-agent-config with resource: "variation", configKey, variationKey, variationName, model, and prompts -- add the variation
  3. get-agent-configs -- verify the result

Execute all three steps without stopping to ask for details. Infer the variation key (default), name (Default), instructions/messages, and model from the user's request context. If the user asked for GPT-4o agent mode, you have enough to complete the entire flow. Only ask clarifying questions if the mode or model is truly ambiguous.

Step 4: Verify

If you created the config with its first variation in one call, verification is automatic: the response includes the full config with variations. Check:

  1. Config exists with the correct mode
  2. Variation has a model assigned (not "NO MODEL")
  3. Instructions or messages are present
  4. Parameters are set

Use get-agent-configs for the verification call — do not drop to raw curl + jq. The MCP tool returns a typed object you can inspect directly. Hand-rolled jq filters against the REST response routinely break: the configs detail endpoint returns the variation list under different keys depending on expand, and a filter like .variations.items[] will fail with Cannot index array with string "items" when the response shape is a bare array. If you must call the REST API, use jq -e . first to inspect the actual shape before drilling in.

Report results:

  • Config created with correct structure
  • Variation has model assigned
  • Flag any missing model or parameters
  • Provide config URL: https://app.launchdarkly.com/projects/{projectKey}/ai-configs/{configKey}

Step 5: Make the variation servable

create-agent-config creates the variation but do not promote it to fallthrough. The new config will return enabled=False to every consumer until targeting is updated. This is the single most common "I created a config but my SDK still gets the fallback" failure. The workflow is not complete until this step is done.

What to tell the user

Print this checklist verbatim to the user after Step 4, then wait for confirmation. Do not claim the skill succeeded until the user confirms the fallthrough was flipped.

✅ Config and variation are created.

🔴 The SDK will return enabled=False until you flip targeting on. The fallthrough is currently pointing at an auto-generated disabled variation, not at the {variationKey} you just created.

Next step — run /configs-targeting with these inputs:

  • Project key: {projectKey}
  • Config key: {configKey}
  • Environment key: the env whose SDK key is in your .env (usually test or production)
  • Fallthrough variation: {variationKey} (the one this skill just created)

Verify after targeting is flipped by:

  1. Opening the config in the LD UI, switching to the correct environment, and confirming "Default rule serves: {variationName}" is shown with targeting On.
  2. Running a quick test: ai_config = ai_client.{completion|agent}_config(...) and asserting ai_config.enabled is True.
Direct shortcut if the user wants to flip targeting without invoking the sibling skill

configs-targeting is the canonical path — it handles percentage rollouts, targeted rules, and individual targets. For the simplest case ("promote the new variation to fallthrough in one environment"), call update-agent-config with resource: "targeting" and a fallthrough after the user agrees:

{
  "projectKey": "{projectKey}",
  "configKey": "{configKey}",
  "resource": "targeting",
  "env": "{envKey}",
  "fallthrough": {"variationKey": "{variationKey}"},
  "confirm": true
}

Then call get-agent-configs with configKey, section: "targeting", and env to confirm the default rule serves that variation.

Do not use turnTargetingOn — that semantic-patch instruction does not work for configs. Setting the fallthrough is what makes the config serve the new variation.

modelConfigKey Format

Required for models to display in the UI. Format: {Provider}.{model-id}

  • OpenAI.gpt-4o
  • OpenAI.gpt-4o-mini
  • Anthropic.claude-sonnet-4-5
  • Anthropic.claude-3-5-sonnet

create-agent-config validates this format and rejects invalid values.

Edge Cases

Situation Action
Config already exists Ask if user wants to update instead
Variation shows "NO MODEL" Use update-agent-config with resource: "variation" to set modelConfigKey
Need to attach tools Create tools first (tools skill), then update the variation

What NOT to Do

  • Don't create configs without understanding the use case
  • Don't skip the two-step process (config then variation)
  • Don't try to attach tools during initial creation -- update the variation afterward
  • Don't forget modelConfigKey (models won't show in the UI)
  • Don't omit modelName from the initial variation call. It is required at create time; setting it via a follow-up PATCH is a workaround for a bug, not the intended flow. The PATCH field is also modelName, not name.
  • Don't drop to raw curl + jq for verification. Use get-agent-configs (MCP) — it returns a typed object and avoids brittle jq filters that break on response-shape variation.
  • Don't consider the workflow complete until the user has been told to run configs-targeting. A created variation that isn't promoted to fallthrough returns enabled=False to every consumer.

More resources

To learn more about creating a config in the LaunchDarkly UI, read Create configs

To learn more about configuring the SDK, read:

Related Skills

  • tools -- Create tools before attaching
  • configs-variations -- Add more variations for experimentation
  • configs-update -- Modify configs based on learnings

Source: SKILL.md on GitHub

skilld matched fixed text patterns in SKILL.md and file names. Patterns miss obfuscated code.

skilld run checks every file with the same patterns. It asks for approval before it loads a Skill with a behavior marked Needs approval.

No alerts11d3 checks · Risk SAFE
  • Gen Agent Trust Hub15d

    The skill provides instructions for managing LaunchDarkly AI configurations using an MCP server. It follows standard integration practices and includes helpful warnings about configuration states.

  • Socket11d

    No alerts

  • Snyk15d

    Risk: LOW · No issues

Signed by skilld at f0ee110. This ties the file your Agent reads to that commit on GitHub. It does not review the instructions.

Last checked against GitHub yesterday.

Activeupdated 2 weeks ago
compatibility
Requires the remotely hosted LaunchDarkly MCP server
metadata
{
  "author": "launchdarkly",
  "version": "1.0.0-experimental"
}
  • MCP
  • launchdarkly
  • ai-config
  • agent-mode
  • completion-mode
  • llm
  • model-routing

README badge

README badge for launchdarkly/ai-tooling/configs-create

Creates and configures AI configs in LaunchDarkly by choosing between agent and completion mode, setting up model and prompt variations, and verifying the config structure. Targets LaunchDarkly's MCP server and requires follow-up targeting configuration before the SDK will serve the config as enabled.

Generated from the current SKILL.md.

Does this skill actually make the config servable, or do I need to do something after?
The skill creates the config and variation, but the SDK will return `enabled=False` until you run `/configs-targeting` to flip the fallthrough targeting. This is a required separate step — creation alone does not make the variation live.
Should I use agent mode or completion mode?
Use agent mode if you're building with LangGraph, CrewAI, or Strands and need a persistent instructions string. Use completion mode for direct OpenAI/Anthropic API calls, full message control, or online evaluations. If unsure, completion mode is the safer default.
What is the modelConfigKey format, and what happens if I get it wrong?
Format must be `{Provider}.{model-id}` (e.g., `OpenAI.gpt-4o`, `Anthropic.claude-sonnet-4-5`). The tool validates this and rejects invalid values. Without it, the model will show as "NO MODEL" in the UI.
Can I attach tools to the config during creation?
No. Create the config and variation first, then use the `tools` skill to create tools separately, and finally update the variation to attach them.
This skill requires the LaunchDarkly MCP server — how do I set that up?
The skill requires the remotely hosted LaunchDarkly MCP server to be configured in your Claude environment before use. Check your Claude client setup for MCP server registration.

Generated from the current SKILL.md. These answers refresh after source changes.