Skip to content

Chat Command Quick Start: /model, /think, and Slash Commands ​

Slash commands are the main form of OpenClaw commands: type a line starting with /model in the chat box, and Gateway handles it directly — switching models, adjusting thinking, starting new sessions, invoking skills, all without touching configuration files. Commands are handled uniformly by Gateway, so the Control UI chat box, the terminal TUI, and Feishu/Telegram chat channels all share the same set.

The official slash command documentation has 744 lines; this lesson won't memorize them one by one. Instead, we'll go through the five most common daily categories: looking up commands, switching models, adjusting thinking, managing sessions, invoking skills, plus a set for checking status/usage. All examples are based on OpenClaw v2026.10.9.

What You'll Be Able to Do After This Lesson ​

  • Use /help and /commands to look up the currently available OpenClaw command catalog at any time
  • Use the /model family to switch models: /model list to browse, /model <provider/model> -s to switch only the current session, /model status to check endpoints
  • Use /think to adjust thinking levels and /fast to switch fast mode
  • Use /new, /reset, /name, /stop to manage the session lifecycle
  • Use /skill <name> to invoke skills as commands, and know why /verbose, /trace, and /reasoning can't be enabled in group chats

Your Current Pain Points ​

  • Want to try a different model? You either go to Control UI and click through the dropdown, or edit openclaw.json — in a mobile IM there's nothing to click at all
  • A session has run for hundreds of messages and Claw starts to "forget things"; you want a clean new session but worry about losing the model configuration
  • You've installed several skills, but each time you have to describe them at length in natural language — you want to invoke them directly with a single command

When to Use This Technique ​

When you need to:

  • Complete daily operations with a single command from any chat entry point (Control UI, TUI, IM channels)
  • Direct Claw remotely from your phone — with no terminal to type in, commands are your remote control
  • Temporarily switch a model or adjust a thinking level, then switch back when done

And you don't want to:

  • SSH in to edit the configuration and restart the Gateway every time you tweak a parameter
  • Dig through 744 lines of official documentation to find the usage of one command
  • Expose internal reasoning and plugin diagnostic information in group chats

🎒 Preparation Before Starting ​

  • Completed the Daily Use Guide; if you're unfamiliar with chat entry points, first read Control UI: The Console in Your Browser
  • Gateway is running: openclaw gateway status shows the listening status (commands are handled by Gateway; if Gateway is down, no one picks up your commands)
  • At least one model provider is configured (if not, go to Connecting Models Overview first)
  • Open any chat entry point: the Control UI chat box, the terminal with openclaw to enter the TUI, or an already-connected chat channel

Core Idea ​

OpenClaw commands fall into three categories (per the official documentation):

CategoryRepresentative CommandsBehavior
Regular commands/new, /reset, /skill, /compactThe entire message must be only the command; Gateway handles it directly, without going through the model
Directives/think, /fast, /verbose, /trace, /reasoning, /elevated, /exec, /model, /queueIntercepted before the model processes the message; sent alone = saved as a session setting with an acknowledgment; mixed into the body = a one-off prompt, mostly not persistent
Inline shortcuts/help, /commands, /status, /whoamiExecuted immediately and stripped from the message; the model only sees the remaining body

Three general rules to remember first to avoid pitfalls:

  1. Commands must be sent as "the whole message". /new behaves differently when mixed into a long paragraph versus sent alone (covered in detail in the pitfall notes).
  2. Commands only take effect for authorized senders. If someone unauthorized sends a command, the Gateway treats it as plain text; on external channels, unauthorized pure command messages are silently ignored.
  3. Both commands and their receipts go into the conversation history, so the model can later see what you invoked—this is a feature, not a bug (/btw is the exception; it does not enter history).

The switches for all commands live in the commands.* section of the config: text (default true, parses /... in chat), native (default auto: Discord/Telegram register native command menus, Slack off), bash/config/mcp/plugins/debug (all default to false, must be enabled manually), restart (default true, manages /restart, /update). The defaults are enough for everyday use; advanced tips come later.

Follow along with me ​

Step 1: Send your first OpenClaw command—/help and /commands ​

Why: The command catalog is dynamic—installing plugins, installing skills, or toggling switches all change which commands are available. Learn to "look it up" first; no need to memorize.

Send the command as the whole message:

text
/help
/commands

You should see: /help returns a short help summary; /commands returns the full command catalog. These commands are executed immediately by the Gateway—no queueing, no model involvement—so the response is instant.

While you're at it, try one more:

text
/whoami

You should see: your sender id (alias /id). When troubleshooting "why doesn't my command have permission," the first step is to compare it against the authorization config.

💡 Colon syntax

You can add an optional colon between the command and its arguments: /think: high is equivalent to /think high. It reads better when the arguments themselves contain spaces or special characters.

  • /commands listed the commands available in the current session

Step 2: Switch models with /model—the star among OpenClaw commands ​

Why: /model is the most-used OpenClaw command: temporarily switch to another model for a reply, pin a cheap model to a session, or check which one is actually in use.

First check the current one:

text
/model

You should see: the model selected for the current session and usage guidance.

Then browse the catalog and pick a model:

text
/model list                        # browse providers (equivalent to /models)
/models deepseek                   # list this provider's model catalog
/model deepseek/deepseek-v4-pro -s # switch only the current session

You should see: /model list lists configured/credentialed providers; /models deepseek lists the model catalog (default 20 per page, limit=5 changes the page size, all disables pagination); the switch command returns a confirmation.

/model's three scope levels, memorized with one table (long flags are --session, --agent, --global):

TargetCommandEffect
Change only the current session/model <model> -sThe configured default stays untouched
Also change the agent default/model <model> -a (requires owner/admin)Takes effect in this session + requests updating that agent's config default
Also change the global default/model <model> -g (requires owner/admin)Takes effect in this session + requests updating agents.defaults.model

Without -s/-a/-g, the default is also to change only the current session (unless agents.defaults.modelSelectionScope is configured); without owner/admin permissions, -a and -g will be rejected. To restore the configured default or view details:

text
/model default -s   # clear this session's model selection and revert to the config default
/model status       # detailed view: auth candidates for each provider; if a custom endpoint is configured, also that endpoint's baseUrl and API mode

💡 Domestic models switch the same way

Model references are always provider/model (split on the first /). After connecting DeepSeek, Qwen, GLM, Kimi, MiniMax, or Doubao, forms like /model deepseek/deepseek-v4-pro and /model qwen/qwen3.5-plus work directly—see Connecting models: overview for each provider's catalog. Model IDs that carry a built-in / (OpenRouter style) must include the full prefix, e.g. /model openrouter/moonshotai/kimi-k2.

💡 When a switch takes effect

If the agent is idle: the new model is used on the very next turn. If it's running: the switch queues until the next safe retry point. Also, the model reference you pick is strict—if it's unreachable, the reply fails explicitly and will not silently fall back to the fallback chain. On Discord, the native /model pops up an interactive picker; Telegram uses callback buttons to browse (both kinds of selection always apply only to the current session).

  • /model status can show current model and endpoint info

Step 3: /think to adjust thinking levels, /fast to toggle fast mode ​

Why: With the same model, simple questions don't need "deep thought" while hard ones deserve more of it—/think lets you adjust the level anytime within a session, no model switch needed.

text
/think high      # set the thinking level (level names follow the current model)
/think default   # clear the session override and revert to the default

You should see: The command receipt confirms the level has been saved as a session setting (aliases /thinking, /t). Level names aren't hardcoded: Discord/Telegram native command menus dynamically list the available levels based on the current session's model—/model switches the model, and /think's options change accordingly.

Fast mode is the opposite direction—faster responses:

text
/fast status     # check the current status
/fast on         # turn on (options: auto/on/off/ultrafast/default)
/fast default    # clear the session override

You should see: /fast shows or sets fast mode. Note that /fast is provider-dependent (OpenAI/Codex use the priority tier, Anthropic maps to service_tier), so even with a saved preference the provider may not honor it.

⚠️ Changing levels can be slower and costlier

Some providers factor thinking configuration into the cache key: even with the model unchanged, just adjusting the /think level can force the entire conversation to be reprocessed on the next turn—raising latency and input token costs. Frequent level changes within a session are not free; the pitfall notes elaborate on this.

  • /think default cleared a level override once

Step 4: /new and /reset—managing the session lifecycle ​

Why: the longer a session, the heavier its context. /new opens a new one, /reset clears in place, /name names it, /stop stops abruptly—these four commands cover the entire lifecycle of a session, from creation to wrap-up.

text
/new                          # Archive the current session and start a new one
/new deepseek/deepseek-v4-pro # Start a new session and pick the model directly
/reset                        # Reset the current session in place
/reset soft                   # Soft reset: keeps the transcript and reruns startup
/name weekly-report-assistant    # Name/rename the session (no argument = show the current name and suggestions)
/stop                         # Abort the currently running turn

You should see: /new returns a new-session confirmation; /reset returns an in-place reset confirmation; /stop returns an abort notification (it only stops the current turn; queued input and subsequent runs are untouched).

The argument of /new <model> accepts aliases, provider/model, or provider names (fuzzy matching)—if nothing matches, the text is sent into the new session as the message body, so be careful not to typo.

Two easily overlooked behaviors:

  • Model pins are not lost: explicitly selected models and auth pins survive /new, /reset, session scrolling, and compaction (while still valid). To clear them, use /model default -s.
  • /new in the Control UI is a bit special: the web version intercepts the typed /new to create and switch to a new dashboard session (it only resets in place when session.dmScope: "main" is configured and the current session is the main one); /reset still goes through the Gateway's in-place reset as before.

If you don't want a new session and just want to lighten the context, there are two middle options: /compact [instructions] compresses the current session's context; /fork [title] copies the current conversation into a standalone session (in the Control UI this corresponds to Fork conversation).

  • Started a new session with /new and confirmed the model pin is still there

Step 5: /skill, the universal entry point—skills as commands ​

Why: after installing a skill, the most efficient way to invoke it is not a natural-language description but a one-line command. Skills marked user-invocable: true (the default) are exposed directly as slash commands.

text
/skill <name> [input]    # Universal entry point—any skill can be invoked this way

You should see: the skill is invoked and starts executing. Skills can also register themselves as commands under their own name—command names are normalized to a-z0-9_ with a maximum of 32 characters, and duplicates get a numeric suffix (when the built-in /dashboard is taken, a user skill with the same name registers as /dashboard_2; $dashboard and /skill dashboard can still select it directly).

In the Control UI's input box there's an even handier trick: selecting a skill from command completion inserts a $skill-name reference (e.g., "Please use $weather to check the weather in Sydney"), with at most 8 skill references per message; uppercase shell variables like $HOME and $PATH don't count as references.

To learn new skills while chatting:

text
/learn save the troubleshooting steps from just now as a skill

You should see: Skill Workshop starts learning—reusable flows become skills, while facts and preferences go into the memory plugin. Details in Skill Workshop: Letting Claw Learn Skills on Its Own.

  • Invoked an installed skill via /skill <name>

Step 6: /status, /tools, and /usage—checking status, tools, and usage ​

Why: when something goes wrong, check the status first—that's the universal troubleshooting order for all systems. These three commands answer respectively: how is it running, what's available right now, and how much has it cost.

text
/status        # Execution/runtime status, uptime, plugin health, provider usage quotas
/tools         # Tools available to the current agent at this moment (compact view)
/usage tokens  # Append a token footnote to each reply (options: off/tokens/full/reset/cost)

You should see: /status returns a screenful of runtime status—Execution is the effective sandbox path, Runtime is who is running this session (OpenClaw Default, OpenAI Codex, the CLI backend, or the ACP backend); with usage tracking enabled you can also see the current provider's quota line (e.g., "Claude 80% left"). The result of /tools is session-scoped: changing the agent, channel, sender authorization, or model may change the result; a tool being listed doesn't mean you're authorized to run its actions.

Remember the division of labor in one sentence: /status shows runtime and usage, /model status shows models, auth, and endpoints—it doesn't cover usage. To see the detailed version of plugin health (load errors, quarantines, compatibility notices), /status plugins requires enabling commands.plugins: true first.

  • Found the Execution / Runtime lines in /status

Checkpoint ✅ ​

  • /commands can list the command catalog available in the current session
  • Switched models once with /model <provider/model> -s, viewed endpoint info with /model status
  • Cleared a thinking-level override once with /think default
  • Started a new session with /new, and know that the model pin is preserved
  • Can explain why /verbose, /trace, and /reasoning shouldn't be enabled in group chats

Pitfall Reminders ​

❌ A command is sent but nothing happens ​

There can be three layers of causes; check them in order:

  1. The command wasn't sent as an entire message: ordinary commands mixed into the body text don't trigger; directives mixed into the body are one-off prompts and won't be saved as session settings
  2. The sender isn't authorized: directives from unauthorized users are treated as plain text, and pure command messages from unauthorized users on external channels are silently ignored. Use /whoami to get the sender id and compare it against the authorization config
  3. The Gateway isn't running: commands are handled by the Gateway; if the process is stopped, no one picks them up. Confirm with openclaw gateway status first

Correct approach: send the command as its own standalone message; when commands.allowFrom is configured, remember it is the only source of command authorization—if you're not on the list, you're not on the list.

❌ Enabling /reasoning, /verbose, or /trace in a group chat ​

Cause: these three commands expose internal reasoning, tool output, or plugin diagnostics—which may include tool parameters, URLs, and data the model has seen—not suitable for public channels.

Correct approach: keep them off in group chats; enable them only in trusted DMs or tightly controlled rooms. /verbose is for debugging anyway—keep it off in day-to-day use.

❌ /model 3 can't select a model ​

Cause: numeric selection is not supported in text commands—/model 3 is invalid.

Correct approach: use the full reference /model <provider/model> or a configured alias (e.g., /model Opus). Also, /models add is deprecated and no longer registers models in chat—model onboarding goes through configuration; see Model Onboarding Overview.

❌ Switching the /think level made things slower and more expensive ​

Cause: some providers factor the thinking configuration into the cache key—even without changing the model, just adjusting the /think level can force the next turn to reprocess the entire conversation, raising latency and input token costs.

The right approach: keep the thinking level stable within a session, and if you need to change it, change it once and be done. Similarly, it's best to pick the model for a session at creation time—switching models mid-session is an advanced operation, and context limits, tool behavior, and cache hits may all change.

Advanced tips (optional) ​

Enabling owner-only commands. The four commands /config, /mcp, /plugins, and /debug are off by default; they manage config read/write, MCP config, plugin management, and runtime overrides respectively. To use them, enable them in openclaw.json:

json5
{
  commands: {
    config: true,   // /config——读写 openclaw.json,owner-only
    mcp: true,      // /mcp——读写 mcp.servers,owner-only
    plugins: true,  // /plugins——插件发现/安装/启停,写操作 owner-only
    debug: true,    // /debug——运行时覆盖,不落盘,owner-only
  },
}

The host shell is also callable. After commands.bash: true (default false), ! <命令> or /bash <命令> runs the host machine's shell directly—the exclamation mark must be at the start of the command, and the tools.elevated allowlist is also required. hello ! poll and ![diagram](image.png) in ordinary chat won't be affected.

Three tools for fine-grained control of the conversation flow. /btw <问题> (alias /side) asks a side question without interrupting the main flow—it uses the current session as background but doesn't modify the session context or enter the transcript; /steer <消息> (alias /tell) injects guidance into the currently running turn; /followup <消息> queues a message to run in the next turn.

Leave recurring tasks to /loop. /loop 5m check deploy status has the agent create a fixed-interval cron task in the current session (owner-only); without an interval it self-paces. To learn about system-level scheduled tasks, see Scheduled Tasks Automations.

Lesson recap ​

✅ OpenClaw commands fall into three categories: regular commands (whole message, handled directly by the Gateway), directives (intercepted before model processing; sending one alone saves it to session settings), and inline shortcuts (executed immediately, stripped from the message).

✅ The /model family: /model shows the current one, /model list browses, /models <provider> lists directories, /model default -s returns to default, /model status checks the endpoint.

✅ /think <level> adjusts the thinking level (level names follow the current model), /fast toggles fast mode; levels are related to caching, so don't dial them frequently.

✅ Four session commands: /new archives and starts fresh, /reset (soft keeps the transcript) resets in place, /name names it, /stop emergency-stops; the model pin survives /new//reset.

✅ /skill <name> is the universal entry point—skills are commands (a-z0-9_, at most 32 characters, suffix added on name conflicts); /learn learns skills on the spot.

✅ Three status tools: /status shows running state + usage, /tools shows currently available tools, /usage shows the reply footer; in group chats, don't enable /verbose, /trace, or /reasoning.

CommandPurposeNotes
/model <provider/model> -sSwitches only the current session's model-a/-g requires owner/admin
/model default -sClears the session model pinReverts to the configured default
/think <level> / /think defaultSet/clear thinking levelLevel names follow the current model
/fast on|off|auto|ultrafastFast modeProvider-dependent, not guaranteed to satisfy
/new [model] / /reset [soft]Start a new session / reset in placeModel pin is preserved
/skill <name> [input]Invoke a skillUniversal entry point
/status / /tools / /usageStatus / tools / usage footer/model status doesn't track usage
/help / /commands / /whoamiList directories / show sender idInline shortcuts

For a complete, command-encyclopedia-level list, see CLI Commands and Configuration Quick Reference.

Next lesson preview ​

The commands in this lesson are all "effective on the spot" directives; the next lesson, Memory System: Letting Claw Remember You, covers how to make the effects persist—saying "Remember that I prefer TypeScript" writes it into ~/.openclaw/workspace's Markdown memory files.

You will learn:

  • Four memory files: USER.md, MEMORY.md, memory/YYYY-MM-DD.md, DREAMS.md
  • Cross-session recall in 2.0: remembering you across DMs with the same agent (on by default for personal installs)
  • Chinese trigram tokenization-based retrieval in the built-in engine
  • Importing existing memories from Claude Code / Codex / Hermes

Related tutorials ​

gaodong.aiAboutPrivacyContact

Independent tutorials, not affiliated with any product mentioned. Product names and trademarks belong to their owners. Check official pages for prices and policies.