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

# Mock Mode & Node Pinning

> Iterate on workflows without burning real tool calls, and freeze specific outputs so re-runs reuse cached results.

Two features help you iterate on workflows quickly and safely:

* **Mock Mode** — a per-node toggle that makes a node return synthetic data instead of hitting the real world.
* **Node Pinning** — freezes a node's output so subsequent runs skip it and reuse the cached value.

They look similar at a glance but solve different problems, and the editor shows them in separate canvas toolbar indicators. Both are essential for productive development inside Agent Mode.

## Mock Mode

### What it does

When a node is in mock mode, running the workflow never actually calls its tool. Instead, the runtime returns synthetic data that matches the node's expected output schema. This is perfect for:

* Building the graph without spamming a downstream Slack channel.
* Iterating on a Code Block that consumes an expensive API response.
* Drafting a new workflow where some upstream tools aren't configured yet.

### Turning it on

Two ways to toggle mock mode for a specific node:

1. **In the node settings panel**, toggle **Mock mode**.
2. **Right-click the node** → **Toggle Mock Mode** from the context menu.

Mocked nodes display a small flask indicator on the node itself, so you can tell at a glance which nodes are synthetic.

### The Mock Mode indicator

On the canvas toolbar (top-left), a flask icon with a numeric badge shows how many nodes are currently in mock mode. Click it to open a popover listing each mocked node — click a node to jump to it on the canvas, or click **Clear all** to return every node to live mode at once.

### Release-gate rule

<Warning>
  A workflow cannot be released until it has at least one successful **live** run — a run where **no nodes** were in mock mode. This prevents a mocked workflow from going to production by accident. See [Releases](/agentic-editor/releases).
</Warning>

If you try to release a workflow that's only ever run in mock mode, the **Release** button is disabled with a tooltip explaining why. Unmock every node and trigger at least one live run to unblock the release.

### Customizing mock output

By default, mock output matches the node's declared output schema with sample values. You can override with custom JSON by expanding the **Mock response** section in the node's settings panel.

## Node Pinning

### What it does

Pinning freezes the current output of a node. On the next run, the workflow skips the pinned node entirely and reuses its last output. Use pinning for:

* **Caching expensive upstream calls** — pin a node whose output you know is correct, then iterate on downstream nodes without re-hitting the expensive call.
* **Reproducing a bug** — pin all upstream nodes to their current outputs and tweak the failing node in isolation.
* **Speeding up debug loops** — a 5-minute workflow becomes 5 seconds when all upstream nodes are pinned.

### Turning it on

Run the workflow at least once (so there's an output to freeze), then:

1. **Right-click the node** → **Pin output**, or
2. Click the **pin** button in the node's hover menu or settings panel.

Pinned nodes display a pin indicator and don't re-execute on subsequent runs — they just forward their cached output to downstream nodes.

### The Pinned Nodes indicator

The canvas toolbar also shows a pin icon with a count of currently pinned nodes. Its popover lists pinned nodes and offers **Unpin** per item plus a **Clear all** button.

### When pins invalidate

Pinned outputs are tied to the node's configuration. If you change a pinned node's settings (arguments, connection, code, etc.), the pin is automatically cleared — the cached output no longer matches what the node would produce. You'll see a warning toast when this happens.

Pins also clear when the workflow is released — released workflows always run fresh.

### Result pin (different thing)

Inside the **Result tab** there's also a pin button. That pin keeps a specific node's output visible in the Result tab even when you click away to other nodes — it doesn't affect execution. It's a UI convenience, not a caching mechanism.

## Mock vs. Pin at a glance

|                               | Mock Mode                                   | Node Pinning                                  |
| ----------------------------- | ------------------------------------------- | --------------------------------------------- |
| Effect on execution           | Skips the tool call, returns synthetic data | Skips the node entirely, reuses cached output |
| Requires a prior run?         | No                                          | Yes                                           |
| Cleared when settings change? | No (explicit toggle)                        | Yes (auto-invalidated)                        |
| Canvas indicator              | Flask icon                                  | Pin icon                                      |
| Blocks release?               | Yes, must have a live run                   | No                                            |
| Best for                      | Building before the real tool is configured | Speeding up iteration on downstream nodes     |

## What's next

<CardGroup cols={2}>
  <Card title="Running a workflow" icon="play" href="/agentic-editor/running">
    The execution flow that mock and pin interact with.
  </Card>

  <Card title="Releases" icon="rocket" href="/agentic-editor/releases">
    The live-run gate explained in depth.
  </Card>

  <Card title="Node types" icon="cubes" href="/agentic-editor/node-types">
    Which nodes support mock mode and pinning.
  </Card>
</CardGroup>