> ## 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 shortcut, but you can drive it all in plain English.

Helix is a natural-language router — you can just say what you want. The `*command` shortcuts 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.             |

## Lifecycle

| Command                    | Stage                                 | Does                                                               |
| -------------------------- | ------------------------------------- | ------------------------------------------------------------------ |
| `*spec` · `*validate-spec` | [Spec](/helix/lifecycle/spec)         | Run the guided interview; validate the resulting `agentspec.yaml`. |
| `*build` · `*sync-spec`    | [Build](/helix/lifecycle/build)       | Implement the spec; resync it from implementation drift.           |
| `*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>

## 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`   |

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

<Tip>
  Shortcuts and plain English are interchangeable, and so is calling a skill directly (for example
  `/mutagent-evaluator`). Use whichever is fastest for you.
</Tip>