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

# Running simulations from MCP

> How to get a guided, orchestrated simulation experience when using the Lorikeet MCP server.

In Coach, simulations work because Coach loads **skills** — guided recipes that handle the right multi-step sequence (set up a test customer, write strong assertions, choose the right execution environment, etc.) automatically based on your intent. You don't think about skills; they just happen.

**The MCP server is different.** MCP exposes the underlying Lorikeet tools directly to your AI assistant — there's no automatic orchestration. If you just say *"create a sim for the refund flow"*, the AI calls raw tools and often misses prerequisites: simulations created without test customer profiles, weak assertions, wrong execution environment, silent failures that look fine in the UI.

To get the same guided experience over MCP, you invoke the skill explicitly.

<Info>
  **Coach**: skills load automatically from intent.
  **MCP**: skills must be invoked explicitly — syntax varies by client.
</Info>

## How to invoke a sim skill on MCP

<Tabs>
  <Tab title="Claude Code">
    Type the skill as a slash command at the start of your prompt:

    ```
    /lorikeet:create-simulations build simulations for the refund workflow
    ```

    Claude Code will load the recipe and follow it end-to-end.
  </Tab>

  <Tab title="Claude (desktop / web)">
    Ask Claude to load the skill explicitly, then describe your task:

    ```
    Load the Lorikeet create-simulations skill, then build sims for the refund workflow.
    ```

    Claude calls the MCP `load_prompt` tool to fetch the skill content, then proceeds.
  </Tab>

  <Tab title="ChatGPT">
    With the Lorikeet app enabled in your workspace:

    ```
    Use the Lorikeet load_prompt tool to load the "create-simulations" skill, then build sims for the refund workflow.
    ```
  </Tab>

  <Tab title="Other MCP clients">
    For Cursor, Continue, Cline, and other MCP clients, the universal pattern works:

    ```
    Use the Lorikeet load_prompt tool to load "create-simulations", then build sims for the refund workflow.
    ```
  </Tab>
</Tabs>

<Warning>
  Skip the skill invocation and the AI improvises from raw tools. Most common consequences: simulations created without test customer profiles, weak or missing assertions, wrong execution environment, silent failures. Always invoke the skill first.
</Warning>

## End-to-end example: creating and running sims via MCP

Here's the canonical flow using Claude Code. Adjust the slash command syntax per the tabs above for other clients.

<Steps>
  <Step title="Create simulations for a workflow">
    ```
    /lorikeet:create-simulations create simulations for the refund workflow,
    covering valid refunds, expired return windows, and missing orders.
    ```

    The skill will:

    * Analyze the workflow
    * Set up a test customer profile if needed
    * Generate scenarios with clear instructions and initial messages
    * Define expected results and assertions
    * Confirm with you before creating
  </Step>

  <Step title="Run the simulations">
    ```
    /lorikeet:run-simulations run the simulations I just created and report the results.
    ```

    The skill will execute the batch, poll for completion, and present pass/fail with reasoning per scenario.
  </Step>

  <Step title="Iterate on failures">
    ```
    /lorikeet:simulation-driven-development iterate on the failing sims until pass rate is at least 90%.
    ```

    The skill will classify each failure, propose targeted fixes, apply them on a draft, re-run, and repeat until the target is hit.
  </Step>

  <Step title="Edit a scenario if needed">
    ```
    /lorikeet:update-simulations strengthen the assertions on the "expired return window" scenario.
    ```
  </Step>

  <Step title="Review your sim coverage">
    ```
    /lorikeet:review-simulations review the simulations for the refund workflow — what's missing?
    ```

    The skill grades expected-result reliability, instruction clarity, test customer completeness, and coverage.
  </Step>
</Steps>

## Simulation skills reference

| Skill                           | When to use it                                                                 |
| ------------------------------- | ------------------------------------------------------------------------------ |
| `create-simulations`            | Create new test scenarios and test customers for a workflow                    |
| `run-simulations`               | Execute existing simulations and review results                                |
| `update-simulations`            | Edit an existing scenario (instructions, assertions, expected results)         |
| `review-simulations`            | Audit existing simulations for coverage, clarity, and quality                  |
| `simulation-driven-development` | Iterate to push simulation pass rates higher (audit → baseline → fix → re-run) |

## Other Lorikeet skills available via MCP

The same skill-invocation pattern works for non-simulation tasks. Replace `create-simulations` with the relevant skill name:

| Skill                 | Purpose                                                      |
| --------------------- | ------------------------------------------------------------ |
| `edit-workflow`       | Safely edit a workflow on a draft version                    |
| `build-guardrail`     | Create or improve a guardrail                                |
| `diagnose-guardrails` | Analyze guardrail performance and find gaps                  |
| `knowledge-creator`   | Add new knowledge to Lorikeet, routed to the right primitive |
| `knowledge-gaps`      | Find missing knowledge from escalated tickets                |
| `understanding-tqs`   | Diagnose why TQS is failing                                  |
| `improve-check-score` | Diagnose and fix a failing TQS check                         |
| `diagnose-ticket`     | Investigate what happened on a specific ticket               |
| `setup-integration`   | Configure a ticketing or external system integration         |
| `design-campaign`     | Design and launch an outbound campaign                       |

## Troubleshooting

**Output looks incomplete or missing setup steps** — you likely didn't invoke a skill. Retry with the slash command or `load_prompt` instruction.

**My MCP client doesn't support slash commands** — use the universal fallback: *"Use the Lorikeet load\_prompt tool to load `<skill-name>`, then…"*.

**I want to see what a skill does before invoking it** — call `load_prompt(<skill-name>)` directly via MCP; the content returns inline.

Still stuck? Reach out to the [Lorikeet team](mailto:support@lorikeetcx.ai).