Verbative

Command a team of AI coding agents, hands-free

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 as its own native chat, sharing one memory. Your dictation and the voice key always go to the agent you've selected: it's highlighted in the panel and its chat wears the orange outline, so you always know where your next prompt lands. Replies stream in as you'd read them, tool calls fold into compact cards, and a permission prompt is a card you answer with a click or your voice.

Verbative
Code Advanced · unlimitedAccount ↗
Signed in as mia@studio.dev
Sign out
UsageWeek 44%Fable 88%
📁 project
Web App · Checkout flow
Idle — waiting for voice command
Speed 1.3×
Voice queue
Web App, Checkout flowBuilt the checkout payment flow; all 18 checkout tests pass.Last▶
Channels
Project memory
Web App✎✕
Checkout flow✎▷↺✕
high▾
Onboarding✎▷↺✕
high▾
+ Add an agent
Mobile App✎✕
Push notifications✎▷↺✕
high▾
+ Add an agent
+ New channel

Each channel runs its own Claude agents in parallel. Your voice goes to the selected agent.

Verbative MemoryON
Verbative Mechanics
Verbative Shot
Drag a region → clipboard · Esc to finish
^⌘S — click to change
Verbative Advisory BoardOFF
ProblemsOutputDebug ConsoleTerminalPortsVerbative
Web App2 agents · 2 live · 1 working
Checkout flow
build the checkout payment flow

Wired up the Stripe PaymentIntent with an idempotency key and the charge path.

recallpayment conventions for this repo0.3s›
Editsrc/checkout/intent.ts0.6s›
Bashnpm test -- checkout2.1s›

All 18 tests pass. Edited src/checkout/intent.ts (+24 −3).

Built the checkout payment flow; all 18 checkout tests pass.
1m 12s · 3 turns
Message Checkout flow…
Idleauto mode23% ctx
Onboarding
finish the onboarding welcome step
recallonboarding copy conventions0.2s›

Built the welcome step and added form validation.

Editsrc/onboarding/Welcome.tsx0.8s›
Bashnpm test -- onboarding1.8s›

All 12 onboarding tests pass.

Built the welcome step with form validation; all 12 onboarding tests pass.
Thinking… · 611 tokens
Message Onboarding…
Working…auto mode31% ctx

One window: the Verbative panel on the left, each agent as a native chat on the right — streamed replies, tool cards, and permission prompts you answer with a click or your voice.

Parallel agents, one voice

Each agent is its own live Claude Code CLI session shown as a native chat, 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.

One memory, every channel

All channels share one real, fully on-device project memory: what any agent decides is captured automatically and recalled by every other agent in the project when it's relevant — each memory tagged with the channel that learned it. 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

A decision made with one agent lands in the project's shared memory — every other agent, in any channel, recalls 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.

›Your prompt
  • { }
    Backend
    Advisor · Haiku · own voice

    API design · DB schema · scalability

  • <>
    Frontend
    Advisor · Haiku · own voice

    UX · a11y · perceived latency

  • ⛨
    Security & Compliance
    Advisor · Haiku · own voice

    GDPR · CCPA · vulnerabilities

  • ✓✗
    QA Engineer
    Advisor · Haiku · own voice

    Edge cases · regression risk · coverage

  • ◐
    Product Manager
    Advisor · Haiku · own voice

    Scope · alternatives · brand trust

  • ↻
    DevOps / SRE
    Advisor · Haiku · own voice

    Deploy · observability · rollback

Tech Lead — synthesizes the advice, writes the code

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.

Read the deep dive

Run a team of AI agents by voice

How parallel agent channels, a shared memory, and voice control come together into hands-free multi-agent coding.

Command the whole team by voice.

Run your agents in parallel, keep them aligned, and stay in the loop — hands-free.

Get Verbative