---
title: "Slash Commands Reference"
source: https://docs.autohand.ai/working-with-autohand-code/slash-commands
---

# Slash Commands Reference

Type / during any session to see available commands. Slash commands give you quick access to session management, code tools, model switching, automation, and configuration without leaving the conversation. Autohand Code ships with over 70 built-in commands.

## Quick reference

| Command | Description |
|---|---|
| /help /? | Show available commands and tips |
| /quit /exit | Exit Autohand |
| /new | Start a new conversation |
| /clear | Clear conversation with automatic memory extraction |
| /model [name] | Choose what model and reasoning effort to use |
| /undo | Revert the last file mutation and last turn |
| /memory | Manage project and user memory |
| /skills | Discover and install skills for your project |
| /skills use [name] | Activate a skill |
| /skills new | Create a new skill from a description |
| /skills search [query] | Search community skills |
| /skills trending | Show trending community skills |
| /skills install [name] | Browse and install community skills |
| /skills remove [name] | Remove an installed skill |
| /skills info [name] | Show detailed skill info |
| /skills deactivate [name] | Deactivate a skill |
| /learn | Deep-analyze project for better skill matching |
| /learn deep | In-depth project analysis |
| /learn update | Update existing skill recommendations |
| /hooks | View configured lifecycle hooks |
| /mcp | Connect to a configured MCP server |
| /mcp install [name] | Browse and install community MCP servers |
| /plan | Plan and break down a complex task |
| /automode | Enable interactive auto-mode for this session |
| /automode status | Check auto-mode progress |
| /automode pause | Pause current auto-mode |
| /automode resume | Resume paused auto-mode |
| /automode cancel | Cancel active auto-mode |
| /repeat [interval] <prompt> | Schedule a recurring prompt at a fixed interval |
| /repeat list | Show all active recurring jobs |
| /repeat cancel <id> | Cancel a recurring job by ID |
| /cc | Toggle context compaction on/off |
| /status | Show current status |
| /about | Show information about Autohand |
| /session [name] | Show current session details or switch to a named session |
| /sessions | List saved sessions |
| /resume [session-id] | Resume a previous session |
| /history [page] | Browse paginated session history |
| /fork | Branch a new session from the active session or an earlier user message |
| /clone | Duplicate the active session branch into a new session |
| /tree | Show the fork and clone tree for this project |
| /export [format] | Export session data |
| /share | Share session |
| /search | Configure web search provider |
| /agents | List configured sub-agent definitions |
| /agents new | Create a new sub-agent from a description |
| /team | Manage agent teams |
| /tasks | Show team task list with status and owners |
| /message [name] [text] | Send a direct message to a teammate |
| /squad | Open and manage the local Autohand Squad runtime |
| /ide | Connect to a running IDE |
| /lint | List available code linters |
| /formatters | List available code formatters |
| /completion [shell] | Generate shell completion scripts |
| /permissions | Display current permission settings |
| /feedback | Submit feedback about the CLI |
| /login | Sign in to your Autohand account |
| /logout | Sign out of your Autohand account |
| /sync | Manage settings sync |
| /settings | Configure Autohand settings |
| /chrome | Continue session in the Autohand Chrome extension |
| /import [source] | Import data from other coding agents |
| /add-dir [path] | Add directories to workspace scope |
| /theme | Change terminal color theme |
| /language [locale] | Change display language |
| /init | Create AGENTS.md file |
| /statusline | Configure status line display |
| /yolo | Toggle YOLO mode |
| /experiments | List and toggle Autohand experiments |
| /go | Pair this session with the Autohand Code iOS app |
| /handoff session | Handoff this session to the iOS app |
| /review | Review your current changes and find issues |
| /deep-research [topic] | Research a topic deeply and save a cited report |
| /autoresearch | Run autonomous experiment loops |
| /autoresearch off | Leave auto-research mode and stop auto-resume |
| /autoresearch clear --yes | Delete session state after explicit confirmation |
| /autoresearch export | Write the experiment dashboard |
| /autoresearch finalize | Write a reviewable finalization plan for kept runs |
| /autoresearch status | Show current session state and stats |
| /pr-review | Review a pull request using gh metadata and diff context |
| /setup | Run the setup wizard |
| /tools | List, inspect, disable, rename, or delete persisted meta-tools |
| /goal | Create, inspect, refine, pause, resume, complete, clear, and queue persistent goals |
| /usage | Show token activity by day, week, or month |

## Session management

Commands for managing conversations, context, and session history.

### /new

Start a fresh conversation. Autohand automatically extracts key facts from the current context into memory before clearing, so nothing important is lost.

``` bash
/new

# Memory is extracted automatically before reset
# Use when switching to a different task
```

### /clear

Clear the current context with automatic memory extraction. Similar to `/new` but stays in the same session.

``` bash
/clear

# Keeps your session but resets the conversation
# Good for freeing up context window space
```

### /session \[name\]

Switch to or create a named session. Sessions persist across restarts, making it easy to work on multiple features at the same time.

``` bash
# Create or switch to a named session
/session auth-refactor

# Switch back to a different session
/session bug-fix-123
```

### /sessions

List all saved sessions with their names and status.

``` bash
/sessions

# Output:
# auth-refactor (active)
# bug-fix-123
# docs-update
```

### /resume \[session-id\]

Resume a previous session by its ID. Restores the full conversation context from where you left off.

``` bash
# Resume a specific session
/resume abc123

# Resume the most recent session
/resume
```

### /history \[page\]

Browse your session history in a paginated list. Each entry shows the session ID, date, project path, model used, and message count.

``` bash
/history

# Browse page 2
/history 2
```

### /export \[format\]

Export the current session to a file. Supports markdown, JSON, and HTML formats for sharing or archiving.

``` bash
/export markdown
/export json
/export html
```

### /share

Generate a shareable link for the current session via autohand.link. Anyone with the link can view the conversation.

``` bash
/share

# Output: https://autohand.link/s/abc123
```

### /quit

Exit Autohand. Your session is automatically saved before closing.

``` bash
/quit

# Also: Ctrl+C, Ctrl+D, or type "exit"
```

### /fork

Branch a new session from the active session or from an earlier user message. Useful for exploring an alternative approach without losing your current conversation.

``` bash
/fork

# Branch from a specific user message
/fork 3
/fork --message 3
```

### /clone

Duplicate the active session branch into a new session. The clone starts with the same context and history as the source.

``` bash
/clone

# Clone a specific session
/clone abc123
```

### /tree

Show the fork and clone tree for the current project, including which session is currently active.

``` bash
/tree

# Output:
# - abc123
#   - def456 (fork)
#   - ghi789 (clone)
```

## Code tools

Commands for working with code, git, and project files.

### /undo

Revert the last file change made by the agent and remove the last conversation turn. Useful when the agent takes a wrong approach.

``` bash
/undo

# Reverts file changes + removes the last turn
# Use when you want to try a different approach
```

### /lint

Run your configured project linters and display any issues found. The agent can then help fix the reported problems.

``` bash
/lint

# Runs eslint, pylint, or whatever is configured
# Agent can fix reported issues automatically
```

### /formatters

List all configured code formatters for each file type in your project.

``` bash
/formatters

# Shows formatter per file type:
# .ts  - prettier
# .py  - black
# .go  - gofmt
```

### /search

Configure the web search provider Autohand uses for lookups. Supports browser-profile (uses your Chrome/Brave cookies), exa, google, duckduckgo, brave, and parallel. API keys are prompted when needed.

``` bash
/search

# Interactive provider selector
/search brave
/search exa
/search google
```

### /init

Generate an AGENTS.md file by analyzing your codebase. The file includes project overview, architecture, build commands, and coding conventions.

``` bash
/init

# Scans your project and creates AGENTS.md
# Includes build commands, architecture, and style
```

### /review

Review your current changes and find issues. Loads the built-in code-reviewer skill and analyzes architecture, security, performance, error handling, and maintainability.

``` bash
/review

# Focus the review on a specific area
/review check error handling in the auth flow
```

### /pr-review

Review a pull request using GitHub CLI metadata and diff context. Gathers PR details with `gh pr view` and inspects the patch with `gh pr diff` before reviewing.

``` bash
/pr-review

# Review a specific PR
/pr-review 123
/pr-review https://github.com/org/repo/pull/123
```

## Model selection

Switch between AI models during a session based on the task at hand.

### /model \[name\]

Switch to a different AI model. Run without arguments to list all available models from your configured providers.

``` bash
# List available models
/model

# Switch to a specific model
/model claude-4-sonnet
/model gpt-4o
/model gemini-2.5-pro
```

**Tip:** Use faster models for simple questions and more capable models for complex reasoning or large refactors.

## Agent teams

Commands for managing multi-agent teams that work together on tasks.

### /team

Show team status or manage the team lifecycle. Displays all active teammates, their current tasks, and progress.

``` bash
# Create a new team
/team create my-feature-team

# Show team status
/team status

# Shut down all teammates
/team shutdown
```

### /tasks

List and manage team tasks. Shows task status, owner, and dependencies across all teammates.

``` bash
/tasks

# Task  Status       Owner
# 1     completed    researcher
# 2     in_progress  frontend
# 3     pending      (unassigned)
```

### /message \[name\] \[text\]

Send a direct message to a specific teammate by name. Use this to give instructions or ask for updates.

``` bash
/message researcher check the auth module tests
/message frontend update the login form styles
```

### /agents

List all configured sub-agents and their roles. Sub-agents can be assigned specialized tasks within a team.

``` bash
/agents

# Output:
# researcher - Read-only exploration agent
# tester     - Test runner and validator
```

### /agents new

Create a new sub-agent from a description. Define the agent name, role, tools, and permissions in an interactive setup wizard.

``` bash
/agents new

# Walks you through agent creation step by step
```

### /squad

Open and manage the local Autohand Squad runtime. Installs the runtime if needed, opens the Squad UI, and reports status.

``` bash
/squad

# Manage the runtime explicitly
/squad start
/squad status
/squad stop
```

## Skills system

Skills are packages of domain knowledge that expand what the agent can do. They can come from the community registry, your team, or be generated for your project.

### /skills

List all available skills from every source - built-in, community, and project-specific.

``` bash
/skills

# Output:
# frontend-ui  - Create polished UI components
# data-analyst - Analyze datasets and visualizations
# sre          - Infrastructure and incident response
```

### /skills use \[name\]

Activate a specific skill for the current session. The agent gains the skill's knowledge and capabilities immediately.

``` bash
/skills use frontend-ui

# Activates the skill for this session
```

### /skills new

Create a new custom skill with an interactive wizard. Define the skill name, description, instructions, and example prompts.

``` bash
/skills new

# Step-by-step skill creation wizard
```

### /skills search \[query\]

Search for skills in the community registry by name or keyword.

``` bash
/skills search frontend

# Results from community registry:
# frontend-ui       - Build polished UI components
# react-patterns    - Modern React patterns and hooks
# tailwind-expert   - Tailwind CSS design system
```

### /skills trending

Show the most popular community skills right now.

``` bash
/skills trending

# Trending skills this week:
# 1. data-analyst    +240 installs
# 2. sre             +180 installs
# 3. frontend-ui     +150 installs
```

### /skills install \[name\]

Install a community skill from the registry. Without a name, opens the registry browser.

``` bash
# Install by name
/skills install frontend-ui

# Browse the registry
/skills install
```

### /skills remove \[name\]

Deactivate and remove an installed skill.

``` bash
/skills remove old-skill

# Removes the skill from your local config
```

### /learn

Run the LLM-powered skill advisor. Analyzes your project and recommends skills that match your tech stack and workflow.

``` bash
# Standard recommendation
/learn

# In-depth project analysis
/learn deep

# Update existing recommendations
/learn update
```

**Tip:** Use the `--auto-skill` flag when starting Autohand to auto-generate project-specific skills based on your codebase. Use `--learn` for non-interactive skill recommendations.

### /skills info

Show detailed information about an installed skill, including its description, source, and activation state.

``` bash
/skills info frontend-ui

# Also works with aliases
/skills show frontend-ui
```

### /skills deactivate

Deactivate a skill without removing it from your config. Useful for temporarily disabling a skill.

``` bash
/skills deactivate frontend-ui

# Alias
/skills off frontend-ui
```

## Automation

Commands for running the agent in autonomous mode. Auto-mode lets the agent iterate on tasks without waiting for approval at each step.

### /automode

Start an autonomous development loop. The agent works through the task on its own, running tools and making edits until the goal is reached.

``` bash
/automode

# Starts autonomous execution
# The agent works until the task is done
```

### /automode status

Check the current auto-mode progress, including iteration count, cost so far, and elapsed time.

``` bash
/automode status

# Iteration: 12 | Cost: $0.45 | Time: 3m 20s
```

### /automode pause

Pause the current auto-mode run without canceling it. The agent stops after finishing its current step.

``` bash
/automode pause

# Pauses after the current step completes
```

### /automode resume

Resume a paused auto-mode run from where it stopped.

``` bash
/automode resume

# Picks up from the last completed step
```

### /automode cancel

Cancel the active auto-mode run. A changelog of all changes made during the run is generated automatically.

``` bash
/automode cancel

# Stops the run and generates a changelog
```

**Tip:** Auto-mode includes safety features like worktree isolation (changes happen on a separate branch), a circuit breaker that stops after repeated failures, and configurable cost limits.

### /repeat \[interval\] <prompt>

Schedule a recurring prompt that runs at a fixed interval. Useful for polling build status, watching deployments, or running periodic health checks.

``` bash
# Run a prompt every 5 minutes
/repeat 5m check the deploy status and notify me of any errors

# Run every 30 seconds
/repeat 30s run the test suite and report failures

# Default interval is 10 minutes
/repeat check for new PRs that need review
```

### /repeat list

Show all active recurring jobs with their IDs, intervals, and prompts.

``` bash
/repeat list

# ID  Interval  Prompt
# 1   5m        check the deploy status
# 2   30s       run the test suite
```

### /repeat cancel <id>

Cancel a specific recurring job by its ID.

``` bash
/repeat cancel 1

# Cancels recurring job #1
```

### /deep-research

Research a topic deeply and save a cited project report under `.autohand/research/`. The full text after the command is the topic. Autohand chooses an unused `topic-<slug>.md` path, gathers and cross-checks evidence, writes a self-contained Markdown report, and returns the exact path.

``` bash
/deep-research Compare Hermes self-evolving agents and DSPy as of July 2026. \
Use primary sources, connect the findings to this repository, and finish with \
an implementation decision plus rejection reasons.
```

The command currently has no `status`, `pause`, or `resume` subcommands, and `/deep-search` is not an alias. Read the full [`/deep-research` user manual](/docs/guides/teams-and-swarms/deep-research.html) for scoping, parallel evidence tracks, source quality, artifacts, and completion criteria.

### /autoresearch

Run autonomous experiment loops: edit one variable, benchmark, run correctness checks, keep or revert, log the result, and repeat. This is a newer command surface; confirm it appears in `/help` before relying on it.

``` bash
/autoresearch optimize unit test runtime

# Control an active session
/autoresearch status
/autoresearch off
/autoresearch export
/autoresearch finalize
/autoresearch clear --yes
```

Non-interactive aliases are `autohand auto-research ...` and `autohand autoresearch ...`. Start from a clean branch or dedicated worktree: the loop instructs Autohand to commit kept runs and may hard-reset or check out files when discarding failed experiments. Read the full [`/autoresearch` user manual](/docs/guides/teams-and-swarms/autoresearch.html) for flags, metric output, scopes, hooks, artifacts, sub-agent phases, and finalization.

## Plan mode

Plan mode separates thinking from doing. The agent first creates a plan using read-only tools, then executes it only after your approval.

### /plan

Toggle plan mode on or off. You can also press **Shift+Tab** as a keyboard shortcut.

``` bash
/plan

# Or press Shift+Tab to toggle

# Prompt indicators:
# [PLAN] - Agent is in planning phase (read-only)
# [EXEC] - Agent is executing the approved plan
```

### Plan acceptance options

When the agent presents a plan, you have three choices:

-   **Auto-accept** - Approve and execute immediately
-   **Manual approve** - Review each step before execution
-   **Clear context and auto-accept** - Reset context and run the plan fresh

**Tip:** Plan mode is ideal for large refactors where you want to review the approach before any files are modified.

## MCP servers

Commands for managing MCP (Model Context Protocol) servers that extend Autohand with external tools. Supports stdio, SSE, and HTTP transports.

### /mcp

Open the interactive server manager. Use arrow keys to navigate and space or enter to toggle servers on or off.

``` bash
/mcp

# Interactive list:
# > * context7          enabled (12 tools)
#   o database           disabled
# Up/Down navigate  Enter/Space toggle  q close
```

### /mcp add

Browse a curated registry of 12+ servers including github, postgres, brave-search, slack, and more. You can also add a custom server by name and command.

``` bash
# Browse the registry
/mcp add

# Add a specific server from the registry
/mcp add context7

# Add a custom stdio server
/mcp add mydb npx -y @mcp/postgres

# Add an HTTP server with auth header
/mcp add --transport http api https://api.example.com/mcp --header "KEY: val"
```

### /mcp list

List all tools from connected servers, grouped by server name.

``` bash
/mcp list

# context7 (12 tools)
#   resolve-library-id, query-docs, ...
# github (8 tools)
#   create-issue, list-prs, ...
```

### /mcp connect / disconnect \[name\]

Connect to or disconnect from a configured server without removing it from your config.

``` bash
/mcp connect github
/mcp disconnect database
```

### /mcp install \[name\]

Install a new MCP server. Browse the curated registry or install by name.

``` bash
# Browse the registry
/mcp install

# Install a specific server
/mcp install brave-search
```

### /mcp remove \[name\]

Remove a server from your config and disconnect it.

``` bash
/mcp remove old-server
```

## Context and memory

Commands for managing what the agent knows about your project and what it remembers across sessions.

### /memory

View and manage persistent memories. Memory stores key facts, decisions, and preferences that carry over between sessions.

``` bash
/memory

# Shows stored facts like:
# - Project uses TypeScript with strict mode
# - Prefer functional components over class
# - Deploy target is AWS Lambda
```

### /add-dir \[path\]

Add a directory to the workspace context. Useful for monorepos or when you need the agent to see files outside the current working directory.

``` bash
# Add a shared library
/add-dir ./packages/shared

# Add a sibling project
/add-dir ../api-server
```

### /cc

Toggle automatic context compaction. When enabled, the conversation history is compressed as it grows, keeping you within model context limits.

``` bash
/cc

# Status bar shows [CC: ON] or [CC: OFF]
```

## IDE integration

Connect Autohand to your editor for a tighter development loop.

### /ide

Detect running IDEs that have the current workspace open. Supports VS Code, Cursor, Zed, and Antigravity. Shows extension installation hints with marketplace links if needed.

``` bash
/ide

# Detected: VS Code (workspace open)
# Extension: Install from marketplace
# https://marketplace.visualstudio.com/...
```

**Tip:** IDE integration lets the agent open files in your editor, highlight specific lines, and sync changes in real time.

## Settings and personalization

Commands for customizing your Autohand experience.

### /theme

Switch between terminal color themes.

``` bash
/theme

# Cycles through available color themes
```

### /language \[locale\]

Change the display language. Supports 16 locales including en, es, fr, de, ja, ko, zh, pt, it, and ru.

``` bash
# Interactive language selector
/language

# Switch directly to Japanese
/language ja
```

### /permissions

View and manage tool permission settings. Control what the agent can do with files, commands, and network requests.

``` bash
/permissions

# File operations:   allowed
# Shell commands:    ask
# Network requests:  blocked
```

### /completion \[shell\]

Generate shell completion scripts for bash, zsh, or fish. Add the output to your shell config for tab completion of all commands.

``` bash
/completion bash
/completion zsh
/completion fish
```

### /sync

Configure settings sync across devices. Syncs your preferences, skills, and configuration through your Autohand account.

``` bash
/sync

# Toggle sync and choose what gets synced
```

### /search

Configure the web search provider Autohand uses for lookups. Supports browser-profile (uses your Chrome/Brave cookies), exa, google, duckduckgo, brave, and parallel. API keys are prompted when needed.

``` bash
/search

# Interactive provider selector
/search brave
/search exa
/search google
```

### /settings

Open the settings configurator. Organize options by category: ui, agent, permissions, network, telemetry, automode, teams, and search.

``` bash
/settings

# Interactive settings editor with categories
```

### /statusline

Configure what appears in the composer status line, such as provider and model, context remaining, git branch, queued requests, and active-turn metrics.

``` bash
/statusline

# Toggle items interactively
```

### /yolo

Toggle YOLO mode to auto-approve all non-blacklisted tool calls. Run again to disable it and return to interactive approval.

``` bash
/yolo

# Toggles on/off
# Security blacklist still applies
```

### /experiments

List and toggle Autohand experiments (feature flags). Some experiments require a restart to take full effect.

``` bash
/experiments

/experiments list
/experiments status experimental_fork
/experiments enable experimental_fork
/experiments disable experimental_fork
/experiments refresh
```

## Integrations

Commands for connecting Autohand with external tools and importing data.

### /chrome

Hand off the current session to the Autohand Chrome extension. Sets up the native messaging bridge if needed.

``` bash
/chrome

# Opens your session in the Chrome extension
# Installs the native bridge on first use
```

### /import \[source\]

Import configurations, agents, skills, and memory from other coding tools. Supports claude, codex, gemini, cursor, cline, continue, and augment.

``` bash
# Interactive import wizard
/import

# Import from a specific tool
/import claude
/import cursor

# Preview what will be imported
/import --dry-run
```

**Tip:** The import wizard auto-detects which tools are installed on your system and shows only relevant sources.

### /go

Pair this session with the Autohand Code iOS app. Generates a QR code and pairing URL so you can continue the session from your phone.

``` bash
/go

# Queue-only mode
/go --queue

# Live steer mode
/go --steer
```

### /handoff session

Handoff this session to the Autohand Code iOS app. Similar to `/go`, but gated behind the `experimental_handoff` feature flag.

``` bash
/handoff session

# Enable first if needed
/experiments enable experimental_handoff
```

## Authentication

Commands for managing your Autohand account.

### /login

Authenticate with Autohand. Opens your browser for an OAuth flow and stores credentials locally.

``` bash
/login

# Opens browser for authentication
# Credentials stored in ~/.autohand/auth
```

### /logout

Sign out from Autohand and clear stored credentials.

``` bash
/logout

# Clears stored credentials
```

## System

Commands for information, diagnostics, and feedback.

### /help

Show all available commands with descriptions, including any custom commands you have defined.

``` bash
/help

# Lists every built-in and custom command
```

### /status

Show current session status including model, token usage, active tools, and current mode.

``` bash
/status

# Model:  claude-4-sonnet
# Tokens: 12,450 / 200,000
# Tools:  23 active
# Mode:   interactive
```

### /about

Show Autohand version, build info, and system details like OS, Node.js version, and shell.

``` bash
/about

# Autohand Code v0.8.0
# Node.js 22.4.0 | macOS 15.3 | zsh
```

### /hooks

View configured lifecycle hooks. Hooks run automatically in response to 11 different event types during agent operation.

``` bash
/hooks

# before_tool_call  - lint-check.sh
# after_file_change - format.sh
# on_commit         - notify.sh
```

### /feedback

Submit feedback to the Autohand team. Report bugs, request features, or share what is working well.

``` bash
/feedback

# Opens an inline form to submit feedback
```

### /usage

Show token activity by day, week, or month. Helps you track usage patterns and busiest coding days.

``` bash
/usage
/usage daily
/usage weekly
/usage monthly
```

### /setup

Run the setup wizard to configure or reconfigure Autohand. Walks through provider, model, API key, permissions, telemetry, and advanced settings.

``` bash
/setup

# Re-run any time to update configuration
```

### /tools

List, inspect, disable, rename, or delete persisted meta-tools. Meta-tools are custom tools you or the agent have defined.

``` bash
/tools list
/tools show my-tool
/tools doctor
/tools disable my-tool
/tools enable my-tool
/tools rename my-tool my-tool-v2
/tools delete my-tool
```

### /goal

Create, inspect, refine, pause, resume, complete, clear, and queue persistent goals. Goals include a completion contract with proof, boundaries, and a stop rule.

``` bash
/goal add better error messages
/goal writer
/goal queue
/goal pause
/goal resume
/goal complete
/goal clear
/goal templates
```

## Custom commands

Create your own slash commands for prompts you use often.

### Creating custom commands

Custom commands are Markdown files stored in specific directories:

-   **Project commands:** `.autohand/commands/` - Available only in the current project
-   **Personal commands:** `~/.autohand/commands/` - Available in all projects

``` markdown
# .autohand/commands/explain.md

Explain the provided code clearly:
- Summarize what it does
- Highlight key logic and data flow
- Call out assumptions or edge cases
- Suggest improvements when relevant

Focus on: $ARGUMENTS
```

Use the command:

``` bash
/explain authentication logic

# Runs the explain prompt with "authentication logic" as $ARGUMENTS
```

### Command variables

-   `$ARGUMENTS` - Text passed after the command name
-   `@filename` - Include contents of a file
-   `!command` - Run a shell command and include output

## Tips and tricks

### Command autocomplete

Type `/` anywhere in your input to see available commands. Autocomplete works at any cursor position, not just the start of the line.

### Chaining commands with text

You can combine slash commands with natural language in the same input:

``` bash
/model claude-4-sonnet Now analyze this algorithm...
```

### Pipe mode

You can pipe output from any shell command directly into Autohand for analysis:

``` bash
git diff | autohand "explain these changes"
cat error.log | autohand "what went wrong?"
```

### Quick context switch

When switching tasks, use `/new` to start fresh rather than continuing with stale context:

``` bash
/new
Now let's work on the authentication bug...
```

## Frequently asked questions

### What slash commands does Autohand support?

Autohand ships with over 70 built-in slash commands. Key commands include /model for switching AI models, /automode for autonomous loops, /skills for workflow packages, /mcp for external tool servers, /team for multi-agent coordination, /memory for persistent context, /plan for read-only exploration, and /repeat for recurring tasks.

### How do I create a custom slash command in Autohand?

Create a markdown file in .autohand/commands/ (project-level) or ~/.autohand/commands/ (personal). Name the file after your command, such as review.md. Inside, write the prompt text. Use $ARGUMENTS for user input, @filename to include file contents, and !command to embed shell output. The command is available immediately as /review.

### How do I use auto-mode with slash commands?

Type /automode followed by your task description to start an autonomous loop. Use /automode status to check progress, /automode pause to halt the loop, /automode resume to continue, and /automode cancel to stop. The agent works through the task on its own until the goal is reached or limits are hit.