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

# mute: Toggle Incognito Mode to Pause Memory Writes

> Toggle Hyper's incognito mode. When muted, all memory writes are paused across every session while reads via ask and ask-with-history still work.

The `mute` tool toggles incognito mode for your Hyper account. When muted, Hyper pauses all memory writes — nothing from your conversations gets saved to shared team memory, whether triggered by the `Stop` lifecycle hook or an explicit `remember` call. Reads remain fully functional while muted, so you can still use `ask` and `ask-with-history` to query existing team knowledge. Call `mute` again to turn incognito mode off and resume normal memory capture.

## Parameters

`mute` takes no parameters.

## Returns

<ResponseField name="response" type="string">
  Returns `"MUTED"` if incognito mode was just turned **on**, or `"UNMUTED"` if it was just turned **off**. Each call toggles the current state.
</ResponseField>

## Example Calls

### Turning incognito mode on

```python theme={null}
mute()
```

```text theme={null}
MUTED
```

### Turning incognito mode off

```python theme={null}
mute()
```

```text theme={null}
UNMUTED
```

You always get back the new state after the toggle — not the previous one.

## What Mute Affects

| Feature                    | While Muted                           | While Unmuted                       |
| -------------------------- | ------------------------------------- | ----------------------------------- |
| `remember` calls           | Silently dropped — nothing is written | Written to shared memory normally   |
| `Stop` hook memory capture | Paused — observations are not saved   | Active — conversations are captured |
| `ask` queries              | Work normally                         | Work normally                       |
| `ask-with-history` queries | Work normally                         | Work normally                       |
| `connect`                  | Works normally                        | Works normally                      |
| Other team members' writes | Not affected                          | Not affected                        |

<Note>
  Mute is account-scoped and persists **across sessions and clients**. If you mute in Claude Desktop, you'll also be muted in Cursor until you call `mute()` again to unmute. The state is stored server-side in your Hyper account.
</Note>

## When to Use Mute

Mute is designed for sessions where you're doing exploratory, sensitive, or speculative work that you don't want saved to shared team memory:

* **Private investigation** — exploring a sensitive performance issue or debugging a security incident without polluting shared memory with in-progress hypotheses.
* **Drafting mode** — working through ideas that aren't ready to share with the team yet.
* **Demo or sandbox sessions** — running demo conversations in a shared environment where you don't want synthetic activity written to real memory.
* **Personal context** — discussing something with your AI assistant that's personal and out of scope for team memory.

<Tip>
  You can still query team memory freely while muted — `ask` and `ask-with-history` are unaffected. Mute is purely a write guard, not a full disconnect from Hyper.
</Tip>

## Checking Your Current Mute State

There's no dedicated "status" call — the quickest way to check whether you're muted is to look at the `HYPER BRIEFING` block at the start of your session (populated by `connect`), which includes your current mute state. Alternatively, call `mute()` — if it returns `UNMUTED`, you were muted; if it returns `MUTED`, you were unmuted and are now muted again.

<Warning>
  Calling `mute()` to check your status will **toggle** the state. If you're trying to verify without changing anything, check the briefing block instead.
</Warning>

## Relationship to remember

When incognito mode is active, `remember` calls are silently acknowledged — the tool returns `"Remembered."` as usual, but no data is actually written. This preserves the flow of conversation without surfacing an error, while still respecting your privacy preference. If you need to confirm a write actually happened, unmute first, then call `remember`.