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

/agent-graphs

@f0ee110 official
Run it yourself

Create and manage agent graphs — directed graphs of configs connected by edges with handoff logic. Use when building multi-agent workflows where configs route to each other.

Use this Skill: https://skilld.dev/gh/launchdarkly/ai-tooling/agent-graphs

Nothing lands on disk. Nothing to clean up.

Fork this Skill

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

SKILL.md

≈47 tokens for metadata: the name and description. ≈1.4k when used: this 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 ≈188 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.

Config Agent Graphs

You're using a skill that will guide you through creating and managing agent graphs in LaunchDarkly. Your job is to design the graph topology, create it with the right edges and handoffs, and verify the routing between config nodes.

Prerequisites

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

Required MCP tools:

  • create-agent-graph -- create a new graph with nodes and edges
  • get-agent-graphs -- browse existing graphs in the project; with graphKey, inspect one graph's structure and edges

Optional MCP tools:

  • update-agent-graph -- modify edges, root config, or description
  • delete-agent-graph -- permanently remove a graph
  • get-agent-configs -- inspect individual configs that serve as nodes
  • create-agent-config (resource: "config") -- create new configs to use as graph nodes

Core Concepts

What Are Agent Graphs?

An agent graph is a directed graph where:

  • Nodes are configs (each config is an agent with its own model, prompt, and tools)
  • Edges define routing between configs (source -> target)
  • Handoff data on edges controls how context is passed between agents
  • Root config is the entry point — the first agent that receives user input

When to Use Agent Graphs

Scenario Example
Multi-step workflows Triage agent -> Specialist agent -> Summary agent
Routing by intent Router agent decides which specialist handles the request
Escalation chains L1 support -> L2 support -> Human handoff
Pipeline processing Extract -> Transform -> Validate -> Store

Graph Structure

[Root Config] --edge--> [Config A] --edge--> [Config C]
                  \--edge--> [Config B]

Each edge has:

  • key -- unique identifier for the edge
  • sourceConfig -- the config key that routes FROM
  • targetConfig -- the config key that routes TO
  • handoff (optional) -- data/instructions passed during the transition

Core Principles

  1. Design Before Building: Map out nodes and edges on paper/whiteboard first
  2. One Agent, One Job: Each node should have a clear, focused responsibility
  3. Root Config Is the Router: The entry point should understand how to dispatch
  4. Handoff Data Matters: Define what context flows between agents
  5. Verify the Full Path: Test that routing works end-to-end

Workflow

Step 1: Design the Graph

Before creating anything:

  1. Identify the agents (configs) needed — each is a graph node
  2. Map the routing: which agent hands off to which?
  3. Define handoff data: what context does each edge carry?
  4. Identify the root config: which agent receives initial input?
  5. Check existing graphs with get-agent-graphs to avoid duplicates
  6. Check existing configs with get-agent-configs to see what nodes already exist

Step 2: Ensure Nodes Exist

Each node in the graph must be an existing config. If configs don't exist yet:

  1. Use create-agent-config with resource: "config" to create each agent config
  2. Set up variations with appropriate models and prompts for each agent's role (resource: "variation", or pass the first variation's fields in the same call)
  3. Verify each config exists with get-agent-configs

Step 3: Create the Graph

Use create-agent-graph with:

  • projectKey -- the project containing the configs
  • key -- unique identifier for the graph
  • name -- human-readable display name
  • description (optional) -- explain the graph's purpose
  • rootConfigKey -- the entry-point config key
  • edges -- array of connections between configs
{
  "projectKey": "my-project",
  "key": "support-triage-graph",
  "name": "Customer Support Triage",
  "description": "Routes customer queries to the appropriate specialist agent",
  "rootConfigKey": "triage-agent",
  "edges": [
    {
      "key": "triage-to-billing",
      "sourceConfig": "triage-agent",
      "targetConfig": "billing-specialist",
      "handoff": {"category": "billing", "priority": "normal"}
    },
    {
      "key": "triage-to-technical",
      "sourceConfig": "triage-agent",
      "targetConfig": "technical-specialist",
      "handoff": {"category": "technical", "priority": "normal"}
    }
  ]
}

Step 4: Verify

  1. Use get-agent-graphs to confirm the graph was created with the correct structure
  2. Verify edges connect the right source and target configs
  3. Check that the root config key matches the intended entry point
  4. Confirm handoff data is present on edges that need it

Report results:

  • Graph created with N nodes and M edges
  • Root config set correctly
  • All edges verified

Edge Cases

Situation Action
Config doesn't exist yet Create it first with create-agent-config before referencing in a graph
Circular routing Allowed but warn user — ensure there's a termination condition in the agent logic
Single-node graph Valid but unusual — consider if a graph is actually needed
Updating edges Use update-agent-graph with confirm: true — provide the complete new edge list

What NOT to Do

  • Don't create a graph before the config nodes exist
  • Don't forget handoff data when agents need context from predecessors
  • Don't create overly complex graphs — start simple and add nodes as needed
  • Don't delete a graph without understanding if it's actively used in agent workflows

Other Resources

To learn more, read Agent graphs.

Source: SKILL.md on GitHub

No rule matched.

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 alerts15d3 checks · Risk SAFE
  • Gen Agent Trust Hub15d

    The skill is safe to use and describes standard operations for managing multi-agent workflows in LaunchDarkly. It correctly instructs users to use specific tools for graph and configuration management. The only identified concern is the inherent risk of indirect prompt injection within multi-agent architectures.

  • Socket15d

    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": "0.1.0"
}
  • MCP
  • launchdarkly
  • agent-graphs
  • multi-agent
  • routing
  • workflow
  • config
  • handoff

README badge

README badge for launchdarkly/ai-tooling/agent-graphs

Creates and manages directed graphs of LaunchDarkly configs connected by edges with handoff logic, enabling multi-agent workflows where agents route to each other based on intent or task specialization. Use this for building triage systems, escalation chains, or pipeline processing where one agent hands off to another with context passing.

Generated from the current SKILL.md.

Does this skill work with LaunchDarkly's hosted MCP server?
Yes. This skill requires the remotely hosted LaunchDarkly MCP server to be configured in your environment to access the graph management tools.
Can I create circular routing between agents?
Yes, circular routing is allowed, but you must ensure there is a termination condition in the agent logic to prevent infinite loops.
Do the config nodes have to exist before I create the graph?
Yes. Each node must be an existing config. Use create-ai-config to create any missing agent configs before referencing them in a graph.
What happens if I need to modify edges after creating a graph?
Use update-agent-graph and provide the complete new edge list with your changes.
Can I pass context between agents when they hand off?
Yes. Each edge can include optional handoff data that controls what context is passed during the transition between agents.

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