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

# Commands

> The Helix command roster. Every stage has a command, but you can drive it all in plain English.

Helix is a natural-language router — you can just say what you want. The commands below are the
explicit form of the same intents, grouped by the stage that owns them.

## Orchestrator

| Command     | Does                                                                                                        |
| ----------- | ----------------------------------------------------------------------------------------------------------- |
| `/sync`     | Re-index the system.                                                                                        |
| `/status`   | Report where you are in the loop.                                                                           |
| `/onboard`  | Set up or reconfigure.                                                                                      |
| `/help`     | Render the dashboard.                                                                                       |
| `/discover` | Collect traces for a subject — list, fetch, or watch — ahead of an evaluate or diagnose.                    |
| `/feedback` | Send feedback about this session to the Helix team. It shows you what it will send and asks before sending. |

## Lifecycle

| Command      | Stage                                 | Does                                                                                                         |
| ------------ | ------------------------------------- | ------------------------------------------------------------------------------------------------------------ |
| `/spec`      | [Spec](/helix/lifecycle/spec)         | Run the guided interview and validate the resulting `agentspec.yaml`.                                        |
| `/build`     | [Build](/helix/lifecycle/build)       | Implement the spec.                                                                                          |
| `/sync-spec` | [Build](/helix/lifecycle/build)       | Resync a spec from implementation drift. Explicit-only — invoked by name, not shown on the dashboard roster. |
| `/evaluate`  | [Evaluate](/helix/lifecycle/evaluate) | Derive criteria from traces, judge, and return a verdict.                                                    |
| `/diagnose`  | [Diagnose](/helix/lifecycle/diagnose) | Root-cause the flagged failures and rank remedies.                                                           |
| `/optimize`  | [Optimize](/helix/lifecycle/optimize) | Apply an approved remedy and re-run the loop.                                                                |

<Note>
  `/evaluate` is what you want almost always — it's the judge. There's also a separate
  static auditor, `/audit`, for a deeper structural review of a skill or agent. It's explicit-only;
  it's never the fallback for a plain evaluate.
</Note>

## Session commands

The binary also has commands that are not lifecycle intents — `/clear`, `/exit`, `/rename`,
`/thinking`, `/trace`, `/agents`, and the mode-specific `/agent`, `/prime`, `/refine`. They are
listed with what they do on [Sessions](/helix/sessions#session-commands).

## Natural-language queries work too

Every command has a natural-language equivalent, routed automatically to the stage that owns it — so
you don't have to memorise the command surface. These two do the same thing:

<CodeGroup>
  ```text You type theme={null}
  check this agent against my traces
  ```

  ```text Helix runs theme={null}
  /evaluate
  ```
</CodeGroup>

A few more phrasings and where they land:

| You say                                              | Routes to   |
| ---------------------------------------------------- | ----------- |
| "I need an agent that triages inbound support email" | `/spec`     |
| "build it" · "implement the spec"                    | `/build`    |
| "how's it doing on my traces?"                       | `/evaluate` |
| "why are these cases failing?" · "root-cause this"   | `/diagnose` |
| "apply that fix" · "run another pass"                | `/optimize` |
| "where am I in the loop?"                            | `/status`   |

In the binary, type either form into the Helix prompt. In the plugin, boot Helix first with
`/mutagent-helix` (or `*mutagent`) inside your coding agent, then type either form there. When a
request is ambiguous, Helix asks a clarifying question instead of guessing — it never advances a
stage you didn't ask for.

<Tip>
  Commands and plain English are interchangeable. In the plugin you can also call a skill directly
  (for example `/mutagent-evaluator`). Use whichever is fastest for you.
</Tip>