Vibe Delegate
You are the
orchestrator. Hand a bounded coding task to a separate
implementer — the Mistral
Vibe CLI (
) — then review what it produced and land it yourself. You write the brief and own
the judgment; Vibe does the typing in its own session; you verify and commit.
The loop needs only a shell command and file access, so any comparable orchestrator can drive it.
When NOT to use this
- The task is small enough to do inline; delegation overhead is not worth it.
- The CLI is not installed or authenticated.
Prerequisites (check once)
- Install , then Mistral Vibe:
uv tool install mistral-vibe
- Configure your API key with , or set in the environment.
- Confirm succeeds.
- Work in, or point at, the target git repository.
The loop
Run these five steps per task. Steps 1, 4, and 5 require judgment; 2 and 3 are mechanical.
1. Write the brief
Vibe sees only the text you send plus what it can inspect in the workspace — no chat history or shared
context. Include the goal, current state, what to change, what to leave untouched, the project's
actual gates, and a report contract. Tell Vibe not to commit. Keep one task per brief. See
references/writing-the-brief.md.
Default mode cannot approve most shell commands headlessly, so the orchestrator runs the gates. Ask
Vibe to run them only when the human explicitly authorized
.
2. Dispatch
Use the bundled helper. It wraps Vibe's headless
mode, captures the structured event
stream, and writes
. (
is the installed folder containing this
.)
bash
node "<skill-dir>/scripts/relay.mjs" --brief brief.txt --cd /path/to/repo
# limit turns for cost control: add --max-turns <n>
# indicative price threshold/token cap: add --max-price <usd> --max-tokens <n>
# planning/read-only: add --plan-only
# unrestricted shell and tools: add --full-access (explicit authorization required)
# resume the most recent session: add --resume-last (delta brief only)
# resume a specific session: add --session <id> (delta brief only)
# see all options: node .../relay.mjs --help
The child process's cwd pins the workspace. The relay writes artifacts under the system temp dir by
default and never commits. See references/dispatch-and-poll.md.
3. Wait for completion
The helper blocks until Vibe finishes. Run it with the orchestrator's background-command facility, or
background it in the shell and poll for
. A pre-run usage error exits 2 and writes no
result; a missing
exits 127 and writes
status: "vibe_unavailable"
.
The watchdog writes
; terminating the relay on POSIX writes
after stopping Vibe's process tree.
Trust process state and the working tree over a progress display. Completion means the process exited
and
exists.
4. Review — do not trust the self-report
Treat Vibe's final message and gate claims as claims:
- Re-run the project's gates yourself.
- Read the diff against the brief, starting with .
- Run relevant guard skills if installed.
- Round-trip migrations and grep for dangling references after removals or renames.
See references/review-and-land.md.
5. Land it
The implementer edits the working tree;
the orchestrator commits. Commit only after the gates pass
and the diff holds. If rework is needed, send a delta brief with
or
,
then review again.
Autonomy and permissions
In
mode the relay always sets the agent profile explicitly:
| Relay flag | What Vibe gets | Use when |
|---|
| (default) | | Normal implementation — built-in file edits are approved |
| | Read-only review, exploration, or planning |
| | Explicitly authorized runs that need arbitrary shell/tools |
Default mode lets Vibe edit files inside the target worktree. Approval-gated shell commands,
including most project gates, are denied headlessly; the orchestrator runs the gates.
disables Vibe's tool approvals and permits arbitrary shell/tool execution under the
user account; use it only with explicit human authorization. Always inspect
and the
diff after a run.
is always passed to prevent interactive directory-trust prompts in headless runs. It is
not a sandbox and does not grant tool permissions.
Authorization model
Delegation is something the human opts into. Once they have ("run this queue", "proceed"), committing
verified, gate-passing work is the agreed contract. Two limits remain: surface, don't absorb
(report Vibe's design decisions, defensible-but-unasked turns, and non-blocking nitpicks) and stop
for scope changes (if correct completion needs going beyond the brief, ask instead of expanding the
mandate). See references/review-and-land.md.
References
- references/writing-the-brief.md — structure, report contract,
real gates, argv delivery, and delta briefs.
- references/dispatch-and-poll.md — flags, artifacts,
, polling, and failure recovery.
- references/review-and-land.md — review checklist, commit boundary,
and rework through Vibe sessions.
- references/multi-task-queues.md — sequential queues, constraint
carry-forward, progress tracking, and the final coherence pass.