Mistral Vibe 2.0 introduces remote agents — async coding sessions that run in the cloud while you do something else. Spawn a task from the CLI or Le Chat, close your laptop, and come back to a finished PR. This is Mistral’s answer to the “I don’t want to babysit my AI agent” problem, and it changes how you interact with Vibe CLI.

Remote agents run on Mistral Medium 3.5, the 128B dense model with 77.6% SWE-bench and 256K context. Combined with isolated cloud sandboxes, GitHub integration, and parallel execution, Vibe 2.0 turns a terminal coding tool into a background workforce.

What are Vibe remote agents?

A Vibe remote agent is an async cloud coding session. Instead of running Vibe CLI locally and watching it work in real time, you describe a task, hand it off to a cloud sandbox, and the agent works independently. It clones your repo, makes changes, runs tests, and either opens a PR or surfaces questions when it gets stuck.

The key difference from local Vibe sessions: remote agents are non-blocking. You can spawn five agents on five different tasks across five repos, close your terminal, and check results later. Each agent runs in its own isolated environment with its own copy of your codebase.

Think of it as CI for code generation. You define the task, the agent executes in a clean environment, and you review the output — diffs, test results, and a summary of what changed.

Key features

• Spawn from CLI or Le Chat — start remote sessions from your terminal with vibe remote or from Le Chat’s web interface
• Parallel sessions — run multiple agents simultaneously on different tasks or repos
• Teleport local to cloud — mid-conversation, push your local Vibe session to a remote agent and free up your terminal
• GitHub PR integration — agents open pull requests directly with diffs, descriptions, and test results
• Isolated sandboxes — each session runs in a fresh container with your repo cloned and dependencies installed
• Progress tracking — monitor agent state (cloning, planning, coding, testing, blocked) from CLI or Le Chat
• Questions surfaced — when the agent hits ambiguity, it pauses and asks you instead of guessing

How it works

When you start a remote session, Vibe 2.0 provisions an isolated cloud sandbox. Here’s the lifecycle:

1. Clone — the agent clones your repository into a fresh container
2. Plan — it analyzes the codebase, reads relevant files, and creates an execution plan
3. Execute — the agent makes changes, writing file diffs and calling tools (shell commands, file reads, searches)
4. Test — if your repo has tests, the agent runs them and iterates on failures
5. Review — the agent generates a summary of all changes with file-level diffs
6. Deliver — it opens a GitHub PR or presents the diff for your approval

Throughout this process, the agent reports its progress state. You can check in at any time to see where it is:

• cloning — setting up the sandbox
• planning — reading code and building a plan
• coding — actively making changes
• testing — running test suites
• blocked — waiting for your input (a question was surfaced)
• complete — finished, PR opened or diff ready

If the agent encounters something ambiguous — unclear requirements, multiple valid approaches, missing context — it transitions to blocked and surfaces a question. You answer it from CLI or Le Chat, and the agent resumes. This is a major improvement over agents that silently guess wrong and waste 10 minutes going down the wrong path. For more on how agents handle state transitions like these, see our AI agent state management guide.

Integrations

Vibe 2.0 remote agents connect to your existing development tools:

Integration	What it does
GitHub	Clone repos, open PRs, read issues, comment on reviews
Linear	Read tickets, update status, link PRs to issues
Jira	Pull task descriptions, update ticket status
Sentry	Read error traces, investigate exceptions, propose fixes
Slack	Notify channels when agents complete or get blocked
Microsoft Teams	Same as Slack — notifications and status updates

The GitHub integration is the deepest. When you point a remote agent at a GitHub issue, it reads the issue description, pulls linked context (referenced files, related PRs, comments), and uses that as its task specification. When done, it opens a PR that references the original issue.

Sentry integration is particularly useful for bug fixes: point the agent at a Sentry error, and it reads the stack trace, finds the relevant code, and proposes a fix — all asynchronously.

Use cases

Remote agents shine for tasks that are well-defined but time-consuming:

• Module refactors — “Migrate the auth module from callbacks to async/await” across 30 files
• Test generation — “Add unit tests for all public methods in src/services/” — let it grind through boilerplate
• Dependency upgrades — “Upgrade React from 18 to 19 and fix all breaking changes”
• CI investigations — point it at a failing CI run and let it diagnose and fix the issue
• Bug fixes from issues — link a GitHub issue and let the agent read, investigate, and PR a fix
• Documentation generation — “Add JSDoc comments to all exported functions in src/utils/”
• Code review prep — spawn an agent to review a PR and leave comments before you look at it

The pattern: anything you’d describe in a ticket and hand to a junior developer is a good candidate for a remote agent. For a broader look at which tool fits which workflow, see our AI coding agent comparison guide.

Setup guide

Install Vibe CLI

Vibe CLI 2.0 installs via uv (recommended) or pip:

uv pip install mistral-vibe --upgrade

Verify the installation:

vibe --version
# mistral-vibe 2.0.x

Configuration

Set your Mistral API key:

export MISTRAL_API_KEY="your-api-key"

For GitHub integration, authenticate with the GitHub CLI:

gh auth login

Or set a personal access token:

export GITHUB_TOKEN="ghp_your-token"

Configure your default settings in ~/.vibe/config.toml:

[remote]
default_model = "mistral-medium-3.5"
auto_pr = true          # automatically open PRs when done
notify_slack = false     # Slack notifications
sandbox_timeout = 3600   # max session duration in seconds

[github]
default_branch = "main"
pr_prefix = "vibe/"      # branch naming: vibe/task-description

Starting a remote session from CLI

The basic command:

vibe remote "Add input validation to all API endpoints in src/routes/"

This clones your current repo (based on the git remote), provisions a sandbox, and starts the agent. You get a session ID back:

Remote session started: vibe-session-a3f8c2
Repo: github.com/yourorg/yourapp
Status: cloning...

Track progress: vibe remote status a3f8c2

Point it at a specific repo and branch:

vibe remote --repo yourorg/yourapp --branch feature/auth \
  "Fix the race condition in the session middleware"

Point it at a GitHub issue:

vibe remote --issue yourorg/yourapp#142

The agent reads the issue, pulls context, and works on a fix.

Monitoring sessions

Check the status of a running session:

vibe remote status a3f8c2

Session: vibe-session-a3f8c2
Status: coding (step 3/7)
Current: Modifying src/routes/users.ts
Files changed: 4
Duration: 2m 34s

List all active sessions:

vibe remote list

ID        REPO                STATUS     DURATION
a3f8c2    yourorg/yourapp     coding     2m 34s
b7d1e9    yourorg/api         testing    5m 12s
c4a2f0    yourorg/frontend    complete   8m 01s

If an agent is blocked with a question:

vibe remote answer a3f8c2 "Use the existing AuthError class, don't create a new one"

Starting from Le Chat

Le Chat (Mistral’s web interface) has a dedicated remote agents panel. To start a session:

1. Open Le Chat and navigate to the Agents tab
2. Click New Remote Session
3. Connect your GitHub account (one-time setup)
4. Select a repository and branch
5. Describe the task in natural language
6. Click Start

The Le Chat interface shows a real-time dashboard with:

• Agent progress state and current step
• File diffs as they’re generated
• Tool calls (shell commands, file reads) with outputs
• A chat panel to answer questions or redirect the agent

This is the easiest way to use remote agents if you’re not in a terminal. You can start a session from your phone, check in during lunch, and merge the PR from your laptop later.

Teleporting a local session to cloud

Mid-conversation in a local Vibe session, you might realize the task is bigger than expected. Instead of starting over, teleport it:

# Inside a local vibe session, type:
/teleport

Vibe packages your current conversation context, the files you’ve been working on, and the agent’s plan, then uploads everything to a remote sandbox. Your local terminal is freed up, and the agent continues in the cloud.

Teleporting session to cloud...
Context: 12 messages, 4 files, 1 plan
Remote session: vibe-session-d9e3a1
Track: vibe remote status d9e3a1

Local session ended. Agent continues remotely.

This is useful when you start a refactor locally, realize it touches 40 files, and don’t want to keep your terminal occupied for 15 minutes.

Work mode in Le Chat

Work mode is a broader capability in Le Chat that goes beyond coding. It uses remote agents for multi-step tasks that span multiple tools and data sources.

What Work mode does

• Multi-step tasks — break complex requests into subtasks and execute them sequentially or in parallel
• Cross-tool workflows — combine GitHub, Linear, Sentry, Slack, and web search in a single workflow
• Research and synthesis — gather information from multiple sources, summarize, and produce a report
• Inbox triage — process a batch of GitHub issues, categorize them, and draft responses

Examples

“Investigate why deployment failed yesterday” — Work mode reads the CI logs, checks Sentry for new errors, looks at recent commits, and produces a summary with the root cause and a suggested fix.

“Triage the 12 new issues in our backlog” — it reads each issue, categorizes by severity and component, estimates effort, and produces a prioritized list with suggested assignees.

“Research the best approach for migrating our database from Postgres to CockroachDB” — it searches documentation, reads migration guides, checks your schema for compatibility issues, and produces a migration plan.

Work mode is available in Le Chat for Pro, Team, and Enterprise users.

Pricing

Remote agents are available on Mistral’s paid plans:

Plan	Remote agents	Parallel sessions	Sandbox timeout
Pro	✅	Up to 3	30 minutes
Team	✅	Up to 10	60 minutes
Enterprise	✅	Unlimited	Configurable

All remote agent sessions use Mistral Medium 3.5 as the underlying model. Token usage counts against your plan’s allocation. There is no separate per-session fee — you pay for the tokens the agent consumes.

For API users (BYOK), remote agent sessions are billed at Medium 3.5’s standard rate: $1.50 per million input tokens, $7.50 per million output tokens.

Comparison: Vibe 2.0 vs Claude Code vs Codex CLI vs Gemini CLI

How does Vibe 2.0’s remote agent capability compare to the competition? For a deeper dive into terminal tools, see our Aider vs Claude Code vs Codex CLI comparison.

Vibe 2.0’s standout advantages are the teleport feature (no other tool lets you seamlessly move a local session to the cloud) and the breadth of integrations. Claude Code has the edge on raw code quality thanks to Opus 4, while Codex CLI is typically the fastest at execution.

FAQ

Can I use remote agents with my own self-hosted Mistral Medium 3.5?

Not currently. Remote agents require Mistral’s cloud infrastructure for sandbox provisioning. If you self-host Medium 3.5, you can still use Vibe CLI locally — but the remote agent features (cloud sandboxes, GitHub PR integration, parallel sessions) require a Mistral Pro, Team, or Enterprise plan.

How long can a remote session run?

It depends on your plan. Pro allows up to 30 minutes per session, Team up to 60 minutes, and Enterprise has configurable timeouts. Most coding tasks complete well within these limits — a typical module refactor takes 5–15 minutes.

What happens if the agent gets stuck?

The agent transitions to a blocked state and surfaces a question. You’ll see it in vibe remote status or in Le Chat’s dashboard. Answer the question, and the agent resumes. If you don’t respond within the session timeout, the agent saves its progress and the session ends — you can resume from where it left off.

Can I review changes before the PR is opened?

Yes. Set auto_pr = false in your config, and the agent will present the diff for your approval instead of opening a PR automatically. You can review file-by-file, request changes, or approve and let it open the PR.

Is my code sent to Mistral’s servers?

Yes — the agent clones your repo into a Mistral-managed sandbox. The sandbox is ephemeral (destroyed after the session ends) and isolated (no other user or session can access it). For Enterprise plans, Mistral offers dedicated sandbox environments with additional security controls. Your code is not used for training.

Can I use remote agents for private repositories?

Yes. You authenticate via GitHub (OAuth or personal access token), and the agent clones using your credentials. Access is scoped to the repositories you authorize.

How does this compare to just running Vibe CLI locally?

Local Vibe CLI is synchronous — it occupies your terminal and you watch it work. Remote agents are asynchronous — you fire and forget. Use local for interactive, exploratory work where you want to guide the agent. Use remote for well-defined tasks you’d put in a ticket. Both use the same underlying model (Mistral Medium 3.5).

Bottom line

Vibe 2.0 remote agents turn AI coding from an interactive session into an async workflow. The teleport feature, broad integrations (especially Sentry and Linear), and Work mode in Le Chat differentiate it from Claude Code and Codex CLI’s remote offerings. The main trade-off is that Mistral Medium 3.5, while excellent, doesn’t quite match Claude Opus 4 on the hardest coding tasks — but for the 90% of tasks that are well-defined refactors, test generation, and bug fixes, it’s more than capable.

If you’re already using Vibe CLI, upgrading to 2.0 and trying remote agents is a no-brainer. If you’re evaluating terminal AI tools for the first time, check our complete comparison guide to see where Vibe fits in the landscape.