Command a team of Claude Code CLI agents by voice
One voice, a whole team. Group your Claude Code CLI sessions, run several agents in parallel, and keep them aligned.
Put every idea in front of an automatic design-review panel, and let the agents maintain a living Spec → Build → Review → Ship board as they work.
Channels · parallel agents
Operate multiple CLI agents at once. One voice conducts them all.
Real work isn't one thread. Group your Claude sessions into channels and run several agents inside each, all in parallel — every agent in its own terminal split, sharing one memory. Your dictation and the voice key always go to the agent you've selected: it's highlighted in the panel and wears the orange status bar inside its terminal, so you always know where your next prompt lands. And the purple bar pulses on whichever agent is speaking aloud right now.
Each channel runs its own Claude agents in parallel. Your voice goes to the selected agent.
One window: the Verbative panel on the left, each agent's live terminal on the right. Every agent carries a status bar right inside its split — channel, agent, time, tokens, and context used.
Parallel agents, one voice
Each agent is its own live Claude session in its own terminal, working at the same time as the others. Your voice and dictation route to whichever agent you've selected — switch the active agent with a click and your next prompt lands there.
Shared memory per channel
Every channel keeps a shared notes file that's injected into each agent's prompt. Note a decision, file change, or convention there — or ask an agent to — and every other agent sees it on their next turn. No re-explaining context to each session.
Survives a restart — resume in one click
Channels are organized by project, feature, or concern and saved with your repo, so every agent stays bound to its own Claude session. Close VS Code and reopen it — your whole layout comes back, and a single click relaunches an agent straight into its exact conversation, not a blank one. Start over anytime with New session.
Lives in the Verbative panel — pick the active channel and agent, and your voice follows. The layout and each agent's bound session persist in .verbative/workspaces.json in your repo, so reopening VS Code is one click from right where you left off.
Conduct, don't juggle
Select an agent and your voice goes to it. No window-hunting, no copy-paste between sessions.
Shared context
Note a decision in the channel's notes file — or ask an agent to — and every other agent sees it on its next turn.
Parallel by design
Run a build agent, a feature agent, and a review agent at once, each in its own session, all conducted by voice.
Advisory Board · power feature
A standing design-review panel for every idea. One Tech Lead writing the code.
When you're reaching for a new feature or rethinking your architecture, you want a guiding second look before you commit. Flip Advisory Board on and every prompt is reviewed in parallel by a panel of domain advisors — so a fresh design is held up against the standards each discipline cares about: correctness, security & compliance, UX, testability, scope, operability. They speak their concerns aloud in distinct voices, your Tech Lead does the work, then the same panel reviews the result and forces one revision if anything was missed. Bounded at exactly one revision pass — no infinite back-and-forth. And the board is yours: deactivate any advisor or add your own with its own focus and voice.
- { }BackendAdvisor · Haiku · own voice
API design · DB schema · scalability
- <>FrontendAdvisor · Haiku · own voice
UX · a11y · perceived latency
- ⛨Security & ComplianceAdvisor · Haiku · own voice
GDPR · CCPA · vulnerabilities
- ✓✗QA EngineerAdvisor · Haiku · own voice
Edge cases · regression risk · coverage
- ◐Product ManagerAdvisor · Haiku · own voice
Scope · alternatives · brand trust
- ↻DevOps / SREAdvisor · Haiku · own voice
Deploy · observability · rollback
In their lane
Each advisor only speaks when the concern is in their domain. Security flags GDPR risk. Product flags brand exposure. Backend doesn't pile on legal — it focuses on the API surface. Out-of-lane piling-on is explicitly forbidden.
Spoken in distinct voices
Every role gets its own neural voice via Kokoro. You instantly know who's talking — no need to look at the screen. All synthesis runs locally.
Your board, your standards
Activate or deactivate any advisor, or add your own — give it a name, a focus, and a voice, and it joins the review. Click any advisor to see, read-only, the exact instructions it's given. Bounded at one revision pass: review, work, review, one fix — then the loop ends.
Each advisor is a separate, lightweight Haiku call, all running in parallel. Toggle the board in the Verbative panel, or say “advisory board” by voice.
A second look, every time
A fresh design gets reviewed against each discipline's standards before any code is written.
Only speaks when it matters
Each advisor stays quiet unless the concern is truly in its lane — signal, not noise.
Make it yours
Activate, deactivate, or add custom advisors with their own name, focus, and voice.
Project Roadmap · power feature
A map and a board that build themselves as Claude works.
Hands-free, you lose the screen — so you lose the thread of what's done and what's next. Project Roadmap is a live map of your project plus a Spec → Build → Review → Ship board that Claude keeps in sync as it goes. Each card carries its own git lifecycle: a branch when work starts, WIP commits as it builds, a diff to review, a merge and a tag when it ships. As Claude moves cards, Verbative speaks each milestone aloud — so you stay oriented without looking.
Git lifecycle per card
Moving a card isn't cosmetic. Build branches off, commits land as the work progresses, Review surfaces the diff, and Ship merges and tags — so the board and your repo never drift apart.
Kept in sync, hands-free
Claude updates the board as it works — no dragging cards yourself. Each move is spoken aloud (“Updating the roadmap.” … “Roadmap updated.”), so you know what shifted in Spec, Build, Review, or Ship without looking.
A living project map
Beyond the board, Verbative maintains a high-level map of your project so a fresh session — or a fresh you, after a walk — picks up with the full picture instead of a cold start.
Lives in the Verbative panel and in .verbative/ in your repo — kept on your machine (Verbative gitignores it by default). Open it from the panel, or say “project roadmap” by voice.
Four clear stages
Spec, Build, Review, Ship — every card has an obvious state and a matching git lifecycle.
Updated by the doer
The agent moves its own cards as work progresses, so the board never goes stale.
Heard, not watched
Roadmap milestones are spoken aloud, so you stay oriented hands-free and eyes-free.