# What Prompt Strategies Does Fabric Support? A Complete Guide to LLM Reasoning Templates

> Discover Fabric's advanced prompt strategies including Chain-of-Thought and Tree-of-Thought. This guide explores LLM reasoning templates for better AI output.

- Repository: [Daniel Miessler 🛡️/fabric](https://github.com/danielmiessler/fabric)
- Tags: deep-dive
- Published: 2026-02-28

---

**Fabric supports nine built-in prompt strategies including Chain-of-Thought (CoT), Tree-of-Thought (ToT), and Self-Refinement, each stored as JSON files in `data/strategies/` and loaded dynamically by the StrategiesManager.**

Fabric, the open-source AI framework maintained by Daniel Miessler, implements a **prompt strategies** system that controls how large language models approach reasoning tasks. These strategies are predefined prompt templates stored as JSON files, which the system discovers and injects at runtime without requiring code changes. The architecture allows users to switch between reasoning paradigms—from direct answering to complex multi-path exploration—by simply specifying a strategy name.

## How Fabric's Strategy System Works

At the core of the system lies the `StrategiesManager` defined in [`internal/plugins/strategy/strategy.go`](https://github.com/danielmiessler/fabric/blob/main/internal/plugins/strategy/strategy.go). This manager handles discovery, loading, and runtime injection of prompt templates.

### Strategy Discovery and Loading

The `LoadAllFiles()` method walks the strategies directory (default `$HOME/.config/fabric/strategies`) and calls `LoadStrategy()` for every `.json` file encountered. Each file unmarshals into a `Strategy` struct containing `Name`, `Description`, and `Prompt` fields, populating a `map[string]Strategy` registry.

During initialization, `PopulateDB()` clones the repository's `data/strategies/` folder into the user's local configuration directory, ensuring the built-in templates are available immediately after installation. You can customize the search path via the `strategies_git_repo_folder_question` configuration variable.

### Runtime Injection in Chat Processing

When a chat request includes a `strategyName` parameter, the server logic in [`internal/server/chat.go`](https://github.com/danielmiessler/fabric/blob/main/internal/server/chat.go) retrieves the matching `Strategy` object and prepends its `Prompt` content to the LLM request. This happens before the request is sent to the underlying model, effectively wrapping the user's query with the selected reasoning framework.

## The Nine Built-In Prompt Strategies

Fabric ships with nine strategies covering major academic prompting techniques. Each strategy is a standalone JSON file in the `data/strategies/` directory.

- **standard** ([`standard.json`](https://github.com/danielmiessler/fabric/blob/main/standard.json)): Direct answering without explanation.  
  Prompt: `Answer the question directly without any explanation or reasoning.`

- **cot** ([`cot.json`](https://github.com/danielmiessler/fabric/blob/main/cot.json)): Chain‑of‑Thought reasoning.  
  Prompt: `Think step by step to answer the question. Return the final answer in the required format.`

- **aot** ([`aot.json`](https://github.com/danielmiessler/fabric/blob/main/aot.json)): Atom‑of‑Thought decomposition.  
  Prompt: `To solve this problem, break it down into the smallest independent 'atomic' sub‑problems. … Return the final answer in the required format.`

- **ltm** ([`ltm.json`](https://github.com/danielmiessler/fabric/blob/main/ltm.json)): Least‑to‑Most ordering.  
  Prompt: `Break down the problem into simpler sub‑problems from easiest to hardest; answer concisely at each step.`

- **tot** ([`tot.json`](https://github.com/danielmiessler/fabric/blob/main/tot.json)): Tree‑of‑Thought exploration.  
  Prompt: `Generate multiple reasoning paths briefly and select the best one.`

- **cod** ([`cod.json`](https://github.com/danielmiessler/fabric/blob/main/cod.json)): Chain‑of‑Draft minimal reasoning.  
  Prompt: `Think step by step, keeping a minimal draft (5 words max) for each step. Return the final answer in the required format.`

- **self‑refine** ([`self-refine.json`](https://github.com/danielmiessler/fabric/blob/main/self-refine.json)): Iterative self‑correction.  
  Prompt: `Provide an initial concise answer, critique it briefly, and refine if necessary.`

- **self‑consistent** ([`self-consistent.json`](https://github.com/danielmiessler/fabric/blob/main/self-consistent.json)): Multi‑path consistency checking.  
  Prompt: `Provide multiple reasoning paths and select the most consistent answer.`

- **reflexion** ([`reflexion.json`](https://github.com/danielmiessler/fabric/blob/main/reflexion.json)): Answer with integrated critique.  
  Prompt: `Answer concisely, critique your reasoning briefly, and provide a refined answer.`

## Listing Available Strategies

To see which strategies are currently loaded in your Fabric installation, use the CLI flag `--liststrategies`:

```bash
fabric --liststrategies

```

This command invokes `StrategiesManager.ListStrategies()` from [`internal/plugins/strategy/strategy.go`](https://github.com/danielmiessler/fabric/blob/main/internal/plugins/strategy/strategy.go), which iterates the strategy map and prints each entry's `Name` and `Description`. You can also use `fabric --liststrategies=true` for the same output in scripting contexts.

## Creating Custom Prompt Strategies

Fabric's architecture supports hot-loading of custom strategies without recompilation. Any valid JSON file placed in the strategies directory becomes immediately available after restart.

### Strategy File Format

Create a new file at `$HOME/.config/fabric/strategies/my-strategy.json` with the following structure:

```json
{
  "Name": "my-strategy",
  "Description": "Custom reasoning pattern for specific tasks",
  "Prompt": "Analyze the input using the specific framework: 1) Identify entities, 2) Map relationships, 3) Return structured JSON."
}

```

The `Name` field must match the filename (without extension) for the `StrategiesManager` to locate it correctly via `LoadStrategy()`.

### Loading Custom Strategies

After placing the JSON file in the directory, restart the Fabric server. The next invocation of `fabric --liststrategies` will display your custom entry alongside the nine built-in options. When specified via `strategyName`, your custom prompt template is injected into the chat flow exactly like the native strategies defined in `data/strategies/`.

## Summary

- Fabric implements **nine built-in prompt strategies** ranging from direct answering (standard) to complex reasoning trees (ToT) and self-correction loops (reflexion).
- The `StrategiesManager` in [`internal/plugins/strategy/strategy.go`](https://github.com/danielmiessler/fabric/blob/main/internal/plugins/strategy/strategy.go) handles discovery via `LoadAllFiles()` and runtime injection in [`internal/server/chat.go`](https://github.com/danielmiessler/fabric/blob/main/internal/server/chat.go).
- Strategies are stored as JSON files in `data/strategies/` (repository) and `$HOME/.config/fabric/strategies` (user config), following the `Strategy{Name, Description, Prompt}` schema.
- Users can list strategies with `fabric --liststrategies` and add custom ones by dropping new JSON files into the local strategies folder.

## Frequently Asked Questions

### How do I switch between prompt strategies in Fabric?

Pass the strategy name via the `strategyName` parameter in your API request or CLI command. The system calls `StrategiesManager` to load the corresponding JSON file and injects its `Prompt` field into the LLM context before processing your query.

### Can I modify the built-in prompt strategies?

While you should not edit files in the repository's `data/strategies/` directly, you can override behavior by creating a JSON file with the same name in `$HOME/.config/fabric/strategies/`. Fabric prioritizes user configuration directories, so your version will shadow the built-in template.

### What is the difference between CoT and CoD strategies in Fabric?

**Chain-of-Thought (cot)** encourages detailed step-by-step reasoning with full explanations, while **Chain-of-Draft (cod)** forces the model to condense each reasoning step to a maximum of five words, reducing token usage and latency while maintaining accuracy.

### Do custom strategies require restarting the Fabric server?

Yes. Although `LoadAllFiles()` scans the directory at startup, the current implementation in [`internal/plugins/strategy/strategy.go`](https://github.com/danielmiessler/fabric/blob/main/internal/plugins/strategy/strategy.go) does not support hot-reloading without a restart. Place your new JSON file in `$HOME/.config/fabric/strategies/` and restart the service to register the strategy.