> ## Documentation Index
> Fetch the complete documentation index at: https://docs.llmrouter.app/llms.txt
> Use this file to discover all available pages before exploring further.

# Planning

> Automatically trigger 'Chain of Thought' reasoning for complex tasks. Use a Planner Model to strategize the solution before an Execution Model generates the final output.

***

Large Language Models often fail at complex reasoning tasks (like intricate math, deep code refactoring, or multi-step logic puzzles) because they try to generate the final answer immediately.

LLM Router solves this with **Advanced Planning Routing**. By chaining two models together, you can force a "Planner Model" to generate a strict, step-by-step strategy *before* an "Execution Model" writes the final response.

## How Planning Works

When a request arrives, LLM Router analyzes the prompt and generates a **Complexity Score (from 0.0 to 1.0)**.

If this score exceeds your configured `planningTriggerScore`, LLM Router intercepts the request and performs a two-step process:

1. **The Planning Phase:** It sends the prompt and conversation history to your designated **Planner Model**. This model is instructed via a strict System Prompt to *only* generate a logical execution plan, not the final answer.
2. **The Execution Phase:** The resulting plan is injected directly into the system prompt of your designated **Execution Model**, which then generates the final output exactly as the user requested, guided by the flawless strategy.

***

## Defining the Model Chain

You define this Planner/Executor relationship using a specific syntax in your `model` request or within your `gateway.tags` configuration.

**Syntax:** `executorModel:planning:plannerModel`

For example, if you want `claude-3-5-sonnet` to execute the code, but you want `o1-mini` (a specialized reasoning model) to plan it:
`anthropic/claude-3-5-sonnet:planning:openai/o1-mini`

***

## Configuration

You set the complexity threshold that triggers this behavior inside the `gateway` object.

```typescript TypeScript theme={null}
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.llmrouter.app/v1",
  apiKey: process.env.LLM_ROUTER_API_KEY,
});

async function main() {
  const response = await client.chat.completions.create({
    // Define the Executor : planning : Planner
    model: "anthropic/claude-3-5-sonnet:planning:openai/o1-mini",

    messages: [
      {
        role: "user",
        content: "Design a high-throughput microservices architecture for...",
      },
    ],

    // @ts-expect-error - Custom LLM Router extension
    gateway: {
      // Planning will only trigger if the prompt's complexity score is > 0.6
      planningTriggerScore: 0.6,
    },
  });

  console.log(response.choices[0].message.content);
}
main();
```

### Using Planning with Tags

You can also use this syntax directly inside your `gateway.tags` arrays to create incredibly smart, intent-based routing networks.

```typescript theme={null}
gateway: {
  tags: [
    {
      name: "complex_architecture",
      description: "System design, cloud architecture, database scaling",
      models: [
        // If the score > planningTriggerScore, this chain activates.
        "anthropic/claude-3-5-sonnet:planning:deepseek/deepseek-reasoner",

        // Standard fallback if the first chain fails
        "openai/gpt-4o",
      ],
    }
  ],
  planningTriggerScore: 0.75, // Only trigger planning for very hard tasks
}
```

***

## Configuration Properties

### The `gateway` Object

| Property | Type | Default | Description |
| :- | :- | :- | :- |
| `planningTriggerScore` | `number` | `0.6` | The complexity threshold (0.0 to 1.0). If the internal request score is **greater than** `>` this number, the two-step planning chain is executed. If it is lower, the `executorModel` is called normally, bypassing the planner to save latency and costs. |

> [!NOTE]
>
> **Cost & Latency Considerations:** Triggering a planning phase means you are
> making *two* LLM API calls instead of one. Set your `planningTriggerScore`
> high enough (e.g., `0.7` or `0.8`) so that simple requests don't waste time
> and money generating unnecessary plans.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.