Mistral Vibe
██████████████████░░
██████████████████░░
████ ██████ ████░░
████ ██ ████░░
████ ████░░
████ ██ ██ ████░░
██ ██ ██░░
██████████████████░░
██████████████████░░
Mistral's open-source CLI coding assistant.
Mistral Vibe is a command-line coding assistant powered by Mistral's models. It provides a conversational interface to your codebase, allowing you to use natural language to explore, modify, and interact with your projects through a powerful set of tools.
[!WARNING]
Mistral Vibe works on Windows, but we officially support and target UNIX environments.
One-line install (recommended)
Linux and macOS
curl -LsSf https://mistral.ai/vibe/install.sh | bash
Windows
First, install uv
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
Then, use uv command below.
Using uv
uv tool install mistral-vibe
Using pip
pip install mistral-vibe
Table of Contents
Features
- Interactive Chat: A conversational AI agent that understands your requests and breaks down complex tasks.
- Powerful Toolset: A suite of tools for file manipulation, code searching, version control, and command execution, right from the chat prompt.
- Read, write, and patch files (
read, write_file, edit).
- Execute shell commands, with managed shell sessions, polling, and stdin helpers available during rollout.
- Recursively search code with
grep (with ripgrep support).
- Manage a
todo list to track the agent's work.
- Ask interactive questions to gather user input (
ask_user_question).
- Delegate tasks to subagents for parallel work (
task).
- Project-Aware Context: Vibe automatically scans your project's file structure and Git status to provide relevant context to the agent, improving its understanding of your codebase.
- Advanced CLI Experience: Built with modern libraries for a smooth and efficient workflow.
- Autocompletion for slash commands (
/) and file paths (@).
- Image attachments via
@ mentions — .png, .jpg, .jpeg, .gif, .webp files are sent to vision-capable models (e.g. Mistral Medium 3.5) as native multimodal content.
- Persistent command history.
- Beautiful Themes.
- Highly Configurable: Customize models, providers, tool permissions, and UI preferences through a simple
config.toml file.
- Safety First: Features tool execution approval.
- Multiple Built-in Agents: Choose from different agent profiles tailored for specific workflows.
Built-in Agents
Vibe comes with several built-in agent profiles, each designed for different use cases:
ask: Requires approval for tool executions.plan: Read-only agent for exploration and planning. Auto-approves safe tools like grep and read.accept-edits: The default agent. Auto-approves file edits only (write_file, edit). Useful for code refactoring.auto-approve: Auto-approves all tool executions. Use with caution.
Use the --agent flag to select a different agent:
vibe --agent plan
To change the default agent used when --agent is not passed, set
default_agent in your config.toml:
default_agent = "plan"
Valid values are ask, plan, accept-edits, auto-approve,
lean (only when listed in installed_agents), or the name of any
custom agent file in ~/.vibe/agents/ or the project's .vibe/agents/
directory. Subagents such as explore are not accepted.
Note: default_agent applies in both interactive and programmatic
(-p / --prompt) sessions. Pass --auto-approve or --yolo with any
agent when a run should approve all tool calls without prompting.
Subagents and Task Delegation
Vibe supports subagents for delegating tasks. Subagents run independently and can perform specialized work without user interaction, preventing the context from being overloaded.
The task tool allows the agent to delegate work to subagents:
> Can you explore the codebase structure while I work on something else?
🤖 I'll use the task tool to delegate this to the explore subagent.
> task(task="Analyze the project structure and architecture", agent="explore")
Create custom subagents by adding agent_type = "subagent" to your agent configuration. Vibe comes with a built-in subagent called explore, a read-only subagent for codebase exploration and skill loading used internally for delegation.
Interactive User Questions
The ask_user_question tool allows the agent to ask you clarifying questions during its work. This enables more interactive and collaborative workflows.
> Can you help me refactor this function?
🤖 I need to understand your requirements better before proceeding.
> ask_user_question(questions=[{
"question": "What's the main goal of this refactoring?",
"options": [
{"label": "Performance", "description": "Make it run faster"},
{"label": "Readability", "description": "Make it easier to understand"},
{"label": "Maintainability", "description": "Make it easier to modify"}
]
}])
The agent can ask multiple questions at once, displayed as tabs. Each question supports 2-4 options plus an automatic "Other" option for free text responses.
Terminal Requirements
Vibe's interactive interface requires a modern terminal emulator. Recommended terminal emulators include:
- WezTerm (cross-platform)
- Alacritty (cross-platform)
- Ghostty (Linux and macOS)
- Kitty (Linux and macOS)
Most modern terminals should work, but older or minimal terminal emulators may have display issues.
Quick Start
Navigate to your project's root directory:
cd /path/to/your/project
Run Vibe:
vibe
If this is your first time running Vibe, it will:
- Use built-in defaults without creating a configuration file until you
save a setting
- Prompt you to enter your API key if it's not already configured
- Save your API key to
~/.vibe/.env for future use
Alternatively, you can configure your API key separately using vibe --setup.
Start interacting with the agent!
> Can you find all instances of the word "TODO" in the project?
🤖 The user wants to find all instances of "TODO". The `grep` tool is perfect for this. I will use it to search the current directory.
> grep(pattern="TODO", path=".")
... (grep tool output) ...
🤖 I found the following "TODO" comments in your project.
Usage
Interactive Mode
Simply run vibe to enter the interactive chat loop.
- Multi-line Input: Press
Ctrl+J or Shift+Enter for select terminals to insert a newline.
- File Paths: Reference files in your prompt using the
@ symbol for smart autocompletion (e.g., > Read the file @src/agent.py).
- Shell Commands: Prefix any command with
! to execute it directly in your shell, bypassing the agent (e.g., > !ls -l).
- External Editor: Press
Ctrl+G to edit your current input in an external editor.
- Tool Output Toggle: Press
Ctrl+O to toggle the tool output view.
- Todo View Toggle: Press
Ctrl+T to toggle the todo list view.
- Debug Console: Press
Ctrl+\ to toggle the debug console.
- Agent Selection: Press
Shift+Tab to cycle through agents (ask, plan, ...).
- Queueing: Prompts submitted while the agent is working are queued by the app server. Empty
Enter or Ctrl+Enter steers the queued prompts into the active turn; on Unified Harness sessions, this atomically consumes the stored queue item. Ctrl+C removes the newest queued prompt. Escape interrupts the active turn and pauses remaining prompts, and Enter resumes a paused queue. Shell commands and non-side-channel slash commands require an idle session.
- Exit: Type
/exit, exit, quit, :q, or :quit in the input box, or press Ctrl+C / Ctrl+D twice within ~1 second. Set ask_confirmation_on_exit = false (or toggle it in /config) to make Ctrl+D quit on the first press; Ctrl+C always requires confirmation.
Copying & Text Selection
- Copy: Use
Ctrl+Y or Ctrl+Shift+C to copy the current selection to clipboard. With autocopy enabled (default via autocopy_to_clipboard = true), mouse selection automatically copies on release and shows a brief confirmation.
- Multi-click selection: Double-click selects a word, triple-click selects the paragraph. Dragging extends the selection at the same granularity.
You can start Vibe with a prompt using the following command:
vibe "Refactor the main function in cli/main.py to be more modular."
Trust Folder System
Vibe includes a trust folder system to ensure you only run the agent in directories you trust. When you first run Vibe in a new directory which contains a .vibe subfolder, it may ask you to confirm whether you trust the folder.
Trusted folders are remembered for future sessions. You can manage trusted folders through its configuration file ~/.vibe/trusted_folders.toml.
This safety feature helps prevent accidental execution in sensitive directories.
Programmatic Mode
You can run Vibe non-interactively by piping input or using the --prompt flag. This is useful for scripting.
vibe --prompt "Refactor the main function in cli/main.py to be more modular."
By default, it uses your configured default_agent (accept-edits unless changed).
To approve all tool calls without prompting, pass --auto-approve or --yolo
(also available for interactive sessions):
vibe --prompt "Refactor the main function in cli/main.py to be more modular." --auto-approve
Programmatic Mode Options
When using --prompt, you can specify additional options:
--max-turns N: Limit the maximum number of assistant turns. The session will stop after N turns.--max-price DOLLARS: Set a maximum cost limit in dollars. The session will be interrupted if the cost exceeds this limit.--max-tokens N: Set a maximum cumulative LLM token budget for the session, counting both prompt and completion tokens. The session will be interrupted if usage exceeds this limit.--agent NAME: Select the agent profile for this run.--auto-approve, --yolo: Approves all tool calls without prompting, including in interactive sessions. Can be combined with any --agent value.--enabled-tools TOOL: Enable specific tools. In programmatic mode, this disables all other tools. Can be specified multiple times. Supports exact names, glob patterns (e.g., bash*), or regex with re: prefix (e.g., re:^serena_.*$).--disabled-tools TOOL: Disable specific tools after --enabled-tools filtering. Can be specified multiple times. Supports exact names, glob patterns (e.g., bash*), or regex with re: prefix (e.g., re:^serena_.*$).--output FORMAT: Set the output format. Options:
text (default): Human-readable text outputjson: All messages as JSON at the endstreaming: Newline-delimited JSON per message
Example:
vibe --prompt "Analyze the codebase" --max-turns 5 --max-price 1.0 --max-tokens 50000 --output json
Voice Mode
[!WARNING]
Voice mode is experimental and may change in future releases.
Voice mode allows you to dictate input using your microphone instead of typing.
Activating Voice Mode
Toggle voice mode on or off with the /voice slash command:
> /voice
Recording Shortcuts
| Shortcut |
Action |
Ctrl+R |
Start recording |
| Any key |
Stop recording |
Escape |
Cancel recording |
Ctrl+C |
Cancel recording |
Slash Commands
Use slash commands for meta-actions and configuration changes during a session.
Built-in Slash Commands
Vibe provides several built-in slash commands. Use slash commands by typing them in the input box:
> /help
If a model response is interrupted by a backend error, use /retry to continue
from the partial response. Add optional guidance after the command, for example
/retry keep the conclusion concise.
Use /mcp or /connectors to browse configured MCP servers and workspace
connectors. The browser starts on the first item; press Up or Left to focus its
fuzzy search bar, then Up again to wrap to the last item.
Custom Slash Commands via Skills
You can define your own slash commands through the skills system. Skills are reusable components that extend Vibe's functionality.
To create a custom slash command:
- Create a skill directory with a
SKILL.md file
- Set
user-invocable = true in the skill metadata
- Define the command logic in your skill
Example skill metadata:
---
name: my-skill
description: My custom skill with slash commands
user-invocable: true
---
Custom slash commands appear in the autocompletion menu alongside built-in commands.
Skills System
Vibe's skills system allows you to extend functionality through reusable components. Skills can add new tools, slash commands, and specialized behaviors.
Vibe follows the Agent Skills specification for skill format and structure.
Creating Skills
Skills are defined in directories with a SKILL.md file containing metadata in YAML frontmatter. For example, ~/.vibe/skills/code-review/SKILL.md:
---
name: code-review
description: Perform automated code reviews
license: MIT
compatibility: Python 3.12+
user-invocable: true
allowed-tools:
- read
- grep
- ask_user_question
---
# Code Review Skill
This skill helps analyze code quality and suggest improvements.
Skill Discovery
Vibe discovers skills from multiple locations:
- Custom paths: Configured in
config.toml via skill_paths
- Standard Agent Skills path (project root, trusted folders only):
.agents/skills/ — Agent Skills standard
- Local project skills (project root, trusted folders only):
.vibe/skills/ in your project
- Global skills directories:
~/.vibe/skills/ and ~/.agents/skills/
skill_paths = ["/path/to/custom/skills"]
Managing Skills
Enable or disable skills using patterns in your configuration:
# Enable specific skills
enabled_skills = ["code-review", "test-*"]
# Disable specific skills
disabled_skills = ["experimental-*"]
Skills support the same pattern matching as tools (exact names, glob patterns, and regex).
Configuration
Configuration File Location
Vibe is configured via a config.toml file. It looks for this file first in ./.vibe/config.toml and then falls back to ~/.vibe/config.toml.
Theme
The default auto theme follows the terminal background when it can be detected, then the operating-system light/dark preference. Choose another theme with /theme or set it explicitly:
theme = "dracula"
API Key Configuration
To use Vibe, you'll need a Mistral API key. You can obtain one by signing up at https://console.mistral.ai.
You can configure your API key using vibe --setup, or through one of the methods below.
Vibe supports multiple ways to configure your API keys:
Interactive Setup (Recommended for first-time users): When you run Vibe for the first time or if your API key is missing, Vibe will prompt you to enter it. The key will be securely saved to ~/.vibe/.env for future sessions.
Environment Variables: Set your API key as an environment variable:
export MISTRAL_API_KEY="your_mistral_api_key"
.env File: Create a .env file in ~/.vibe/ and add your API keys:
MISTRAL_API_KEY=your_mistral_api_key
Vibe automatically loads API keys from ~/.vibe/.env on startup. Environment variables take precedence over the .env file if both are set.
Note: The .env file is specifically for API keys and other provider credentials. General Vibe configuration should be done in config.toml.
Custom Domains
If you use a Mistral-compatible deployment instead of the default console.mistral.ai / api.mistral.ai, you can point browser sign-in at it. The credential is still a Mistral API key.
Run vibe --setup, choose Launch browser then Other, enter your login domain, and sign in through the browser. A bare domain is prefixed with https://, and the auth API base is derived as DOMAIN/api. The overridden mistral provider is saved to your user config so subsequent runs reuse it.
Note: the wizard reads any custom browser_auth_base_url already set in config.toml. Choosing Other pre-fills that configured domain so you can confirm or edit it. Choosing Mistral AI while a custom domain is configured warns you first — press Enter again to confirm the reset to the default domain, which is then persisted.
TLS and Corporate Certificate Authorities
By default, Vibe uses the bundled certifi certificate roots for outbound HTTPS requests. If your organization installs private certificate authorities in the operating system trust store, you can opt in to the system trust store in config.toml:
enable_system_trust_store = true
SSL_CERT_FILE and SSL_CERT_DIR are still supported and are loaded as additional trust anchors.
OpenTelemetry Tracing
Vibe can export traces for agent, model, and tool operations over OTLP/HTTP. Enable tracing in config.toml:
enable_otel = true
By default, Vibe sends traces to the telemetry endpoint associated with the configure
Mistral Vibe is an open-source command-line coding assistant powered by Mistral's models that gives you a conversational, natural-language interface to explore, modify, and work with your codebase.