Conductor

A voice-driven coordinator for your agents.

Comes with Vibezeo accounts. It uses Vibezeo's servers and switches on when Vibezeo accounts open. Conductor is in the app; until then the download can't make calls. The changelog says what each release contains.

Conductor is a coordinator you talk to. It starts agents, prompts them, reads what they wrote, finds work, changes a few settings and reports back, while you keep your hands on the keyboard or away from it. A call has two parts: a realtime voice model you talk with, and a planner behind it that turns what you asked for into the app's own actions, which run on your computer.

Start and end a call

The Conductor button in the title bar starts a call, and clicking it again ends it. Hold it to talk only while it's held: the call starts muted, holding it unmutes, and letting go mutes again. A push-to-talk call that stays muted for 2 minutes ends on its own.
Mod+Shift+Space starts or ends a call from anywhere in the app.
The wake phrase "Hey Conductor" starts a call hands-free when you turn it on (below), and Conductor says it's listening.
Mute (Mod+Shift+M, or the HUD's mic button) stops sending your voice. Conductor can still talk and keep working.
"Talk faster" and "talk slower" move its speech rate a step for the rest of the call. Settings › Conductor › Speech speed sets where calls start.

The microphone opens as soon as you start a call, so you can talk while it connects: up to 3 seconds of early speech is kept and sent once the call is connected. A call uses the Dictate microphone setting and never opens a Bluetooth headset's mic on its own. While a call has the microphone, Dictate waits. A microphone that stops delivering sound ends the call with "The microphone isn't delivering audio." and a button to switch microphones.

A call ends when you hang up or sign out, or when it reaches its 30-minute limit (with a spoken and on-screen notice 2 minutes before). When it ends, its audio stops at once and anything it was about to type is cancelled.

What it can do

Conductor's planner can only call the tools below, and the app checks every call against the same list before it runs. Tools marked Asks first wait for a yes, and a shell command waits for a click on screen. Tool outputs pass through Vibezeo's secret redactor before Conductor sees them.

Group	Tool	What it does	Asks first
Navigation	`switch_mode`	Switch the app to Agent, Code or Thread mode.	No
Navigation	`open_settings`	Open Settings, at a page when the user names one.	No
Navigation	`toggle_sidebar`	Show or hide the left rail or the right sidebar.	No
Navigation	`open_sidebar_tab`	Open a tab of the right sidebar.	No
Navigation	`open_launch_wizard`	Open the launch wizard, for when the user wants to pick the agents and options on screen.	No
Navigation	`open_routines`	Open the routines view, where scheduled teammate runs are listed.	No
Navigation	`dismiss`	Close the dialog, sheet or menu that is open on screen.	No
Awareness	`list_workspaces`	List the workspaces (folders) with their ids, when the snapshot doesn't say enough.	No
Awareness	`list_panes`	List panes with their ids, names, engines and statuses, in one workspace or all of them.	No
Awareness	`list_threads`	List threads with their ids, titles and statuses.	No
Awareness	`list_teammates`	List teammates with their ids and names.	No
Awareness	`get_waiting`	List everything waiting for the user: approvals, questions and finished work. Call it when the user asks what needs them.	No
Panes and agents	`launch_agents`	Start coding agents in new panes of a workspace, optionally with a first task each.	No
Panes and agents	`prompt_pane`	Type a prompt into an agent's pane. send presses Enter. The app refuses a pane waiting for approval; tell the user then.	No
Panes and agents	`prompt_panes`	Type a prompt into each of several agents' panes: texts[i] goes to panes[i], and each is sent.	No
Panes and agents	`read_pane`	Read the last lines of a pane's terminal; the app redacts secrets first.	No
Panes and agents	`wait_for_pane`	Wait until the agent in a pane finishes or needs the user, for at most timeout seconds.	No
Panes and agents	`focus_pane`	Bring a pane into view and focus it.	No
Panes and agents	`close_pane`	Close a pane. The app asks the user to confirm on screen when its agent is working.	Yes
Panes and agents	`tidy`	Auto-arrange a workspace's panes into an even grid.	No
Panes and agents	`flip`	Toggle Card view for the current workspace: cards instead of terminals, and back.	No
Panes and agents	`handoff`	Hand a pane's work to another engine, with a brief of what was done.	No
Panes and agents	`run_command_in_shell`	Run a shell command in a pane's terminal, only when the user asked for that command. The user always confirms it on screen first.	Yes
Threads	`open_thread`	Open a thread in Thread mode to show it to the user.	No
Threads	`new_thread`	Start a new thread, optionally in a folder, with an engine and a first message.	No
Threads	`send_to_thread`	Send a message to a thread. send false leaves it in the composer for the user to review.	No
Threads	`read_thread`	Read the last messages of a thread; the app redacts secrets first.	No
Threads	`stop_thread`	Stop the turn a thread is running.	No
Threads	`set_thread_mode`	Switch a thread between Plan (it proposes) and Act (it works).	No
Threads	`rename_thread`	Give a thread the title the user asks for.	No
Threads	`archive_thread`	Archive a thread the user is done with: it leaves the list and isn't deleted.	No
Teammates	`open_teammate`	Open a teammate's page: its brief, memory and runs.	No
Teammates	`message_teammate`	Send a message to a teammate, as the user would from its page.	No
Teammates	`create_teammate`	Draft a new teammate from a job description. The user confirms on screen before it is saved.	Yes
Teammates	`pin_teammate`	Pin a teammate to the rail, or unpin it with pinned false.	No
Teammates	`read_teammate_memory`	Read what a teammate remembers.	No
Teammates	`list_routines`	List routines with their ids and schedules.	No
Teammates	`run_routine`	Run a routine now, outside its schedule.	No
Tasks	`create_task`	Create a task with a title and, when the user gives them, details.	No
Tasks	`execute_task`	Start agents on a task. The user confirms on screen first.	Yes
Tasks	`list_tasks`	List tasks with their ids, titles and statuses.	No
Find	`find_work`	Find the pane, thread or teammate the user describes by what it is about, and show it.	No
App	`get_setting`	Read one of the settings Conductor may change.	No
App	`set_setting`	Change one setting from a closed list: theme (light, dark, system), notify_system and notify_sound (true or false), dictate_engine (local or cloud), dictate_mic (a microphone's name), pause_all_mail (true or false), conductor_voice, conductor_tone (neutral, warm, brief) and conductor_verbosity (short, normal, detailed).	No
App	`get_usage`	Read the engines' usage and limits.	No
App	`get_credits`	Read the credit balance that pays for Conductor.	No
App	`check_updates`	Check whether a newer version of the app is available.	No
Review	`review_next`	Move to the next piece of finished work to review, riskiest first, and get what to say about it: who, which branch, what it said, the files changed, what it touches and the check. Call it when the user asks what's ready or says next.	No
Review	`review_send_back`	Send the user's review comment to the agent whose work is being reviewed. Rewrite what they said into a clear instruction first.	No
Review	`review_approve`	Approve the work being reviewed, exactly as it was described. It can't merge; merging waits for the user at the desk.	No

Launching agents opens them in a tab of their own, as the launch sheet does.
Executing a task always starts it in a new worktree lane, with Edits access and review on, never Full access.
Creating a teammate opens the New teammate sheet with what you described filled in; nothing is saved until you save it there.
Settings. set_setting changes only these, and refuses any other key:

Key	Settings page
`theme`	Appearance
`notify_system`	Notifications
`notify_sound`	Notifications
`dictate_engine`	Dictate
`dictate_mic`	Dictate
`pause_all_mail`	Teammates
`conductor_voice`	Conductor
`conductor_tone`	Conductor
`conductor_verbosity`	Conductor

Some things are never available by voice: forcing a lane's removal, turning on Full access, and approving a plugin action that spends money or deletes something. Those always need you in the app.

Walk the review queue

Ask "what's ready?" and Conductor goes through the review queue, riskiest first. For each item it says:

who did the work and on which branch;
what the agent said when it finished;
how many files changed;
what the change touches;
whether the check passed.

From there:

Say "next" to move on.
Say "send it back: …" to have your comment typed to that agent as a review, or sent to its thread. An agent waiting on an approval gets nothing.
Say "approve" to approve exactly what Conductor described. If the agent changed anything since, Conductor says so and reads it again first.

Conductor approves or sends back only an item you've heard, and only when you ask: never in the same breath as describing it, and never because of what an agent wrote. Each call starts the walk over.

Conductor can't merge, discard or stop anything from the queue. When nothing is left, it tells you how many items are approved and ready to merge at your desk. While you listen, the phone's Review tab shows the same item with its diff.

Safety rules

It types into agents, not shells. Conductor types prompts into agent panes and threads. The only way it runs a shell command is run_command_in_shell, and that waits for you to click Yes on screen: a spoken yes can't run it. Typed text has control characters stripped, and Enter is sent separately.
It never types into something that's waiting on you. A pane or thread waiting for an approval gets nothing; Conductor tells you it's waiting instead. A busy agent gets the prompt once it's back at its prompt, and a call that ends first delivers nothing.
A yes answers only the question asked. When Conductor asks you something, the answer you give, by voice or with the HUD's buttons, resolves that one request and nothing else.
No file contents. The planner gets names and states (panes, threads, teammates and what they're doing), never file contents, and what it reads back from a pane or thread is redacted first.

The HUD and the floating ring

During a call a card at the top of the window shows Conductor's ring and its state (Connecting, Listening, Thinking, Working on it or Speaking), the last thing you said, and a chip for each action, with a ✓ or ✗ when it finishes. The newest 3 chips show and older ones fold into +N, which opens the call log. When Conductor asks something, Yes and No appear. The card also shows how long the call has run, with Mute and End.

Settings › Conductor › Floating ring adds a ring that floats over every app. Drag it anywhere and it stays there; click it to start or end a call, hold it to talk, and hover for Mute, Call log and End. If the display it was on is gone, it comes back to the top-right corner of the main one.

Call logs

The call log (Mod+Shift+.) lists each call's turns and actions, and they're kept only on your computer. Settings › Conductor › Keep call logs keeps them for 7 days (the default) or 30 days, or Don't keep: then a call's turns are never written, and the call itself is removed once it's settled.

Persona and memory

Settings › Conductor sets what Conductor calls itself (the wake phrase stays "Hey Conductor"), its voice, its tone (Neutral, Warm or Brief), how much it says (Short, Normal or Detailed), its speech speed (5 steps), and a note telling it about you. A call reads them once, when it starts.

Remember things between calls is off by default. Turned on, Conductor's memory is a file on your computer, memory.md, which Settings › Conductor shows and lets you edit, and every call reads it when it starts. During a call:

"Remember that…" adds a fact. With memory off, nothing is written and Conductor says so.
"What do you know about me" reads back what it remembers.
"Forget…" removes every fact that mentions what you name, as whole words. "Forget it" or "forget that" on its own leaves memory as it is.

It refuses anything that looks like a password, token or key, said or typed. These are handled on your computer, without the planner.

When a call ends, After each call decides what happens to what you said about yourself during it ("I prefer…", "I usually…", "I work on…"): Ask me about new memories (the default) shows each as a card in Settings › Conductor to Keep or Discard, Save automatically adds them, and Don't reflect does neither. While memory is on, each call also adds a line to a journal on your computer with the time, how long the call lasted and which tools it used, never what was said; with Keep call logs set to Don't keep, it adds none. Forget everything… deletes the memory file, the cards and the journal.

The wake phrase

Settings › Conductor › Wake phrase "Hey Conductor" listens for the phrase on your computer, with a small speech model that comes with the app; no audio leaves your computer until a call starts. It uses the Dictate microphone, with a choice of sensitivity (Low, Medium or High), and it pauses while Dictate or a call is using the microphone, while media plays on Bluetooth headphones, and, with Pause while watching videos on (the default), while anything is playing. If the model didn't pass its false-trigger test, the setting stays off and says so.

Privacy

Your voice leaves your computer only while a call is connected. It goes straight from the app to Google's Gemini Live, with a token for that one call from Vibezeo's servers, and the planner's requests (what you asked, and the names and states above) go to Vibezeo's servers and Anthropic's Claude. Google's free service may keep what you say, use it to improve its products and have people review it, so keep private details off calls.

Calls from the EEA, Switzerland and the UK never use Google's free service: they go to a backup voice provider, or Conductor says it isn't available in your country yet. A call Google can't take moves to the backup by itself. The call log stays on your computer, and Vibezeo's servers keep no recording. The privacy page lists every provider.