Verbative

VS Code Extension

Speak. Build.Remember.

Vibecode the Claude Code CLI by voice (hands-free) — a shared on-device memory engine makes every agent sharper with every session. Codex and every MCP agent recall it too.

On-device by default — dictation, transcription, and the whole memory engine run on your Mac.

AVS Codeextension for theClaude Code CLIonmacOS

Hands-free Agentic Development Environment

Verbative turns VS Code into a hands-free, agentic development workspace built around Claude Code CLI. Here's the full set — explore any feature in depth.

Drive the Claude Code CLI entirely by voice — and stay in control of every step.

Explore

Run a whole team of Claude agents and keep them aligned, all conducted by your voice.

Explore

A fully on-device, self-organizing memory shared by all your agents.

Explore

The everyday shortcuts you'll use a hundred times a day.

Explore

Verbative Voice

Separate macOS app

You talk. It types. Into any app on your Mac, in any language — dictation with on-device transcription, no VS Code needed.

Explore

The real thing

Not a mockup — the actual extension

The Verbative panel as it runs in VS Code — not a render.

One panel, completely hands-free

Wake by voice, dictate your prompt, and watch the live equalizer react as you speak. The whole loop — listen, send, approve, hear the result — lives in a single VS Code side panel.

  • On-device or cloud transcription, switchable in a tap
  • Spoken summaries, permission prompts, and progress in your ear
  • Works on your existing Claude Pro or Max plan
Default Channel · Agent 1
Idle — waiting for voice command
Speed 1.3×
Verbative — Voicelive
you
🎙️ “listen — add rate limiting to the login endpoint and write a test for it — stop listeninglisten command
claude
› typing your prompt + running…
claude
🔊 I'd like to edit auth/login.ts to add a rate limiter. Approve, deny, or explain.
you
🎙️ “explainexplain command
claude
🔊 I'll cap each IP to five attempts a minute with a sliding window, returning a 429 when it's exceeded.
you
🎙️ “approveapprove command
claude
✓ editing login.ts…
you
🎙️ “updateupdate command
claude
🔊 Still on it — the limiter's wired in, and I'm writing the expiry test now.
claude
✓ test written · running the suite…
claude
🔊 Done. The limiter's in and its test passes. Running the full suite now to be safe.
commands:listen · wakestop listening · sendhold on · cancelapprove / denyexplainupdatestop clauderepeat / repeat reviewskip / pause / resumeadvisory board

A full voice vocabulary

Every part of the loop has a spoken command — listen, stop listening, approve, deny, explain, update, stop claude and more. Advanced users can rename any trigger to whatever feels natural.

Real-time, on-device

Every millisecond runs on your Mac's GPU — measured, not estimated.

Speech → text

you spokeprocessed invs real time
5 sec0.4 s12×
15 sec0.5 s30×
30 sec0.6 s48×

≈ half a second, however long you talk.

Text → speech

reply lengthprocessed invs real time
5 sec0.22 s23×
15 sec0.65 s23×
30 sec1.3 s23×

A steady ~23×, at any length.

~65 ms to first sound on a short cue · MacBook Advanced, Apple M1 Max · whisper large-v3-turbo + Kokoro, fully on-device.

Voice commandson-device
Listen & dictate
listenWake — start a promptstop listeningSend the prompthold onCancel listening
Approve by voice
approveAllow the pending tooldenyBlock itexplainHear what it would do firstopen queuesRe-hear the open permission cue
Stay in flow
updateLive progress recapstop claudeInterrupt the running taskrepeatReplay the last cueskipSkip the cue playing nowpausePause the cue · resume to continue
Command your team
switch agentNumbered picker — jump focus by numberAdvancedopen agentsNumbered list — open one by numberAdvancedcreate agentNew agent — pick the channel by numberAdvancedcreate channelNew channel — asks for the nameAdvanced
Toggles
advisory boardSix-advisor design review
resumerepeat review+ more

Advanced: tap ✎ to rename any phrase to whatever feels natural

Default Channel · Agent 1
Transcribing on-device…local
Orange = still being transcribedCancelSend ↵
Speed 1.3×

Local dictation · power feature

See your words appear as you speak. Edit them and attach visual context.

In Local mode your prompt is transcribed entirely on your Macwith whisper.cpp — and it streams the text live as you talk, word by word, into an editable box. Caught a wrong word, a missing “not”, a misheard file name? Click and fix it before it ever reaches Claude. No re-recording, no “undo, try again” — just correct it and hit send.

  • Streaming partials from a warm whisper-server — no per-prompt model reload
  • Click any word to fix it before it's sent — a misheard name, a missing “not”
  • Paste an image to attach visual context to your prompt
  • Pick the model (tiny → large-v3) for the accuracy you want
  • 100% on-device — your voice never leaves your Mac

Local transcription is available — and on by default — on every plan.

Default Channel · Agent 1
Listening — any language…local
Deutsch detected→ English
Orange = your words, any languageCancelSend ↵

Speak any language · power feature

Speak in your language. Claude gets a clean English prompt.

Just dictate in German, Spanish, Japanese, French — whatever you think in. Verbative translates your prompt to English on your Macwith whisper.cpp and types it straight into the Claude Code CLI. No audio, no text, ever leaves your machine — the same privacy story as local dictation. There's nothing to switch on: it's always there.

  • Any language in, a clean English prompt out — nothing to set up per language.
  • 100% on-device translation, so your voice never leaves your Mac.
  • Always on, on every plan — local transcription is free and on by default.
  • Your voice commands always stay English — only your prompt is translated.
  • On the full Large v3 model it even names the language it heard.

Speak in ~99 languages— translated to English on-device.

SpanishFrenchGermanItalianPortugueseDutchRussianPolishUkrainianChineseJapaneseKoreanHindiArabicTurkishVietnameseIndonesianCzechSwedishGreek+ dozens more

Quality is strongest for the major languages above; lower-resource languages still work but translate less cleanly.

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.

Verbative
Web App · Checkout flow
Idle — waiting for voice command
Speed 1.3×
Channels
Project memory
📁 project·🌐 global
Web App
Checkout flowOpus 4.8
high
OnboardingOpus 4.8
high
+ Add an agent
Mobile App
Push notificationsOpus 4.8
high
+ Add an agent
+ New channel

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

ProblemsOutputDebug ConsoleTerminalPorts2 splits
build the checkout payment flow
Wired up the Stripe PaymentIntent with an idempotency key and the charge path.
Ran 1 shell command
All 18 tests pass. Edited src/checkout/intent.ts (+24 −3).
Reading 1 file, running 1 shell command…
src/checkout/intent.ts
Web App · Checkout flow
1h12m · 184.6k tok (41%)
Wired the welcome step to the profile API.
Ran 1 shell command
Edited src/onboarding/Welcome.tsx (+12 −3).
Type-checking…
Added a skip-for-now path and an analytics event.
Running the onboarding test suite…
Handled the returning-user redirect.
Ran 1 shell command
All 12 onboarding tests pass.
Validated the email format on the welcome form.
Reading 1 file…
Persisted the draft profile to local storage.
Ran 1 shell command
Wired the “Continue” button to the next step.
Type-checking…
Composing… (still thinking)
Web App · Onboarding
47m18s · 92.3k tok (22%)

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.

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.

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.

Memory · fully on-device

Your agents remember everything. And recall exactly what matters.

More memory isn't better memory. Verbative is built for precision: an on-device model keeps what's worth remembering, while a lossless ledger records every edit, test, and command verbatim. Each prompt gets just the right few memories — decisions, conventions, hard-won dead ends— on a strict token budget. Hard questions get deep recall: the whole story, not fragments. One pool per project. Never a cloud.

Memory● Active

Everything your agents remember — across all channels, this project, and your globalmemory, in one place. Add a memory here or ask an agent to; the relevant ones (plus anything pinned) are auto-injected into each agent's prompts.

Add a memory — a fact, decision, or convention your agents should always remember…

Stored on-device. Tip: keep each memory to one clear sentence.

Remember inProject · shared by all channels ▾Remember
🕘Memorize past conversations25 of 27 memorized — distill the last two into memory, on-device.
🔍 Search all memories…
All📌 Pinned🌐 Global📁 Project💬 Auth💬 Backend

📌 Pinned memories are injected into everyprompt and never trimmed — pin the few always-true rules. Everything else surfaces automatically when it's relevant to what an agent is doing.

11,482 memoriesSort Newest first ▾

Never hand-edit anything under generated/ — pnpm codegen rewrites it on every build. The source of truth is schema/api.yaml.

📌 always in context📁 Projecthow-toJul 8, 2026 · 14:12·used 412×·importance 0.92
codegenconventions
▾ details📌 pinned

The Safari-only login loop was SameSite, not the redirect: the OAuth callback needs the session cookie at SameSite=Lax — deliberate in auth.ts, do not "harden" it back to Strict.

💬 AuthfactJul 11, 2026 · 09:31·used 358×·importance 0.87
safarioauth
▾ details📍 pin

⚠️ AVOID: sharp's parallel mode in the image pipeline — it silently corrupts EXIF rotation on iOS uploads. Tried twice, reverted twice (#214, #367).

💬 Backendhow-toJul 12, 2026 · 18:05·used 291×·importance 0.9
dead-endimages
▾ details📍 pin

Under the hood

the full pipeline, running entirely on your machine

Capture

after each finished turn · two tracks

Goal anchor

knows what the session is working on

Extract

typed facts, rated · dense turns split until they fit

Qwen3 4B

Event ledger

every edit, test, command — lossless

deterministic

Reconcile

updates supersede stale · step-aware

Graph + store

cause→fix edges, edit history, provenance

Recall

every prompt · ~200 ms

Understand

query intent + time windows

Match

one matrix op

Qwen3 embed

Expand

graph + associations

Rerank

precision pass

bge

Ledger evidence

exact edits, test flips, first-seen

verbatim

Inject

budget · stale routed out

Deep recall

on demand, for the hard questions · seconds

The story

problem → cause → fix → verified

Resonance

the question excites the whole record

wave

Interference

weak signals reinforce into peaks

Branch labels

changed values show both readings

Tallies & histories

counts and timelines join in when the question asks

One context

every step present, depth follows relevance

Capture runs two tracks: a model distills durable facts, while a deterministic ledger records every edit, test, and command exactly— so recall can answer “what changed” and “which step fixed it” with verbatim evidence, not a paraphrase. Capture is self-healing: a turn too dense for one pass is split until every fact fits, and nothing is ever dropped silently. Deep recall reads the record the way memory research says brains do — activation spreads from the question across time, files, and the knowledge graph, and the resonant moments surface in full. Agents can also ask directly: the state of any file at any point, when something was first seen, what broke and which edit fixed it, and the net result per file. All of it — capture, recall, consolidation — runs on your machine and never leaves it.

While you sleep

background consolidation, when there's new activity
per-type forgetting curvesusage reinforcementnear-duplicate mergepruninglog compactioninsight synthesiscore-block reflection

Everything is plain files: an append-only log, a deterministic event ledger, a temporal knowledge graph, and a rebuildable vector cache — one project pool plus a private global scope.

223 ms

median on-device retrieval across 1,536 benchmark questions — embeddings plus a 30-candidate reranking pass, no network round-trip

2.6 s

to catch a contradiction and retire the stale fact, fully on-device

1,000,000+

memories in one pool, searched in a single matrix operation with no index to build or maintain — 0.6 s median retrieval at 100,000 memories, 6.4 s stress-tested at 1,000,000

0 cloud calls

storage, search, capture, and consolidation all run on your machine

100+ languages

ask in one language, recall memories saved in another — measured at full parity (German → English)

Measured on the LoCoMo public run and our scale test, on-device (Apple silicon).

Memory · benchmarks

Benchmarked in the open — on the right exams

There are two kinds of memory benchmark, and vendors quote whichever one flatters them. Agent examsgrade memory over real agent work — commands, file states, causal chains — across domains from coding to embodied agents. Conversational exams grade recall across months of personal chat.

Verbative is a coding tool, so AMA-Bench's software domain counts most — but the same engine sits all six domains unchanged, and LoCoMo shows it also holds up on conversation. Pick an exam:

Reproduction harness
Open source

Every Verbative number on this page, rerun from scratch on your own machine.

github.com/verbative/verbative-benchmarks

AMA-Bench — the agent-memory exam

Six domains

The ICML 2026 benchmark for agent memory (arXiv 2602.22769): real agent trajectories with questions on step recall, causal dependencies, state tracking, and abstraction. Its results table's quiet finding: most famous memory products lose to a plain embedding-retrieval baseline, because they compress lossily and rely on similarity search alone — the two failure modes Verbative's engine was built to avoid.

36 episodes · 432 questions · real GitHub bug-fix trajectories (SWE-bench)

Verbative Memory47.9
AMA-Agent (their published verdicts)45.8
The honest test

One prompt. Two agents. Same question.

Don't take our benchmark's word for it — make your own agent measure it, on your own project:

next Friday — paste into the Claude Code CLI:

Spawn two fresh subagents in parallel on the same question:
<any question about your project — a decision, a convention, how something came to be>

Agent A: regular — it must not use the verbative-memory MCP.
Agent B: verbative — it answers via the verbative-memory MCP.

Then give me a side-by-side table: tool calls, tokens used, wall time, and what each answer got that the other missed.

Memory can only compare what it has seen: have capture on while you work — or memorize past sessions first with verbative-memory backfill.

What our own run measured

“Same question, same project. The repo agent: 50 tool calls, five minutes, 18,000 output tokens — and it got the what. The memory agent: 12 calls, 68 seconds, a quarter of the tokens — and it also knew the why and what we'd ruled out. The table doesn't argue. It just shows the difference.”

Your project, your agent, your numbers — black on white.

By capability — as the paper reports it (Table 5, all six domains)

All 16 systems from the paper's results table (Table 5), graded by the authors' own judge across all six domains.

Recallpaper leader 62.4

Retrieving a specific past fact or action from the recorded work.

Verbative Memory
57.2
AMA-Agent (paper's system)
62
Qwen3-Emb-4B (embedding RAG)
48
MemoRAG
47
EMem
46
HippoRAG2
46
Causal Inferencepaper leader 61.5

Why something happened — preconditions and cause→effect.

Verbative Memory
59.4
AMA-Agent (paper's system)
62
MemoRAG
55
HippoRAG2
51
Qwen3-Emb-4B (embedding RAG)
50
EMem
49
State-Updatingpaper leader 53.1

Tracking how something changed over time — the exact target of Verbative's event ledger.

Verbative Memory
68.2
AMA-Agent (paper's system)
53
EMem
45
HippoRAG2
44
MemoRAG
43
Qwen3-Emb-4B (embedding RAG)
35
State Abstractionpaper leader 47.2

Condensing many steps into the durable takeaway — our strongest capability.

Verbative Memory
52.2
AMA-Agent (paper's system)
47
MemoRAG
37
HippoRAG2
35
EMem
34
MemoryBank
33

Benchmark audit — July 2026

We validated the judge first: ours reproduces the authors' own published verdicts at 99% agreement. Verbative's numbers here are the final full-set run across all six domains under that same instrument — every per-question answer and verdict is published in the reproduction repo. Public-leaderboard numbers aren't shown: they are self-reported and not reproducible from the released answers.

Board data from the benchmark paper (Table 5; arXiv 2602.22769, ICML 2026) — the authors' own judge and numbers.

Code-anchored staleness

Memories know which files they cite. When the code changes underneath a fact, agents are told to verify — confirmed facts re-baseline, wrong ones retire.

Point-in-time replay

Ask what any file looked like at any recorded moment — replayed exactly from the edit history, with a label when a later change superseded that state.

Executable memories

“How we deploy” isn’t a description — it carries the exact runnable command, validated so it never points at a script that no longer exists.

Dead-end warnings

Tried-and-failed approaches are first-class memories, injected as explicit AVOID warnings so no agent burns a day on them twice.

Branch-aware answers

When a value changed later, memory shows both readings — the state back then and the correction, each with its step — so agents never confuse “what it was” with “what it became”.

Causal event graph

Every outcome flip links to the edit that caused it, every edit to its file's history, every fact to the code it lives in — agents walk from “why did this break” straight to the exact change.

Replay the published run — every question, unedited, passes and failures.

Analytics, down to every recall

See how many memories your agents have built, how often they're recalled into prompts, and how much of your memory is actually working for you — live, in the Memory panel's own Analytics tab: daily activity, a year of capture at a glance, and the memories your agents lean on most. Every number is computed on your machine from your own memory files. Nothing is reported anywhere.

How memory is performing — computed live from the files on this machine. Nothing leaves your device.

11,482

memories stored

131K

recalls into prompts

78%

of memories used at least once

1,526

new in the last 30 days

5,566 facts·2,829 how-tos·2,341 events·746 entities·11 📌 pinned

Last 30 days

recalled into promptsnew memories
730365
07/0308/01

9,214 new memories in the last year

LessMore
AugSepOctNovDecJanFebMarAprMayJunJulMonWedFri

Most recalled

The memories your agents lean on most.

Never hand-edit anything under generated/ — pnpm codegen rewrites it on every build.412×
The Safari-only login loop was SameSite, not the redirect — keep SameSite=Lax in auth.ts.358×
⚠️ AVOID: sharp's parallel mode in the image pipeline — it corrupts EXIF rotation on iOS.291×
Deploys go through scripts/release.sh — never push images by hand.244×
The staging DB resets nightly at 03:00 UTC — check the clock before debugging "data loss".216×

It reconciles — not just collects

Every new fact is checked against what's known: updates supersede the stale fact, confirmations strengthen it, duplicates never pile up.

It learns and forgets like you do

Importance is rated at capture and fades on forgetting curves. What proves helpful grows stronger — and dead ends stay as explicit warnings.

Yours — private, readable, in your repo

Plain files inside your project, git-trackable on request. No memory cloud, nothing to export — and one npx line plugs the same memory into any MCP-capable agent. Details in the memory docs.

You stay in control

Ask time-anchored questions (“what did we decide last week?”), pin the always-true rules, and give feedback by voice or from the Memory tab — agents can even mark a memory as wrong and it retires on the spot.

Part of Advanced — try the whole plan, memory included, free for 14 days, cancel anytime before it renews. Your memory files stay yours either way. See pricing

Mechanics · power feature

The commands you run all day, one click away.

Every project has the same handful of shell commands you keep retyping — start the dev server, spin up a browser, reset the database, kick off a build. Mechanics are reusable shell scripts you save once and run from the Verbative panel. Organize them into groups you create, rename, and delete; write each script in a built-in editor or import an existing .sh file. Every Mechanic runs in its own terminal — so it gets your real shell and PATH, streams its output live, and stops with one click.

Dev2
Dev server
Storybook
+ Add Mechanic
Chores2
Reset database
Open preview
+ Add Mechanic
+ New group

Each Mechanic runs in its own terminal — your real shell and PATH, live output, one-click stop.

Runs in its own terminal

Each Mechanic launches in a real VS Code terminal, so it inherits your login shell and PATH (the thing a bare command usually trips on), shows live output, and stops cleanly when you hit the button.

Organized in groups

Group related Mechanics together — a Dev group, a Chores group, whatever fits how you work; create, rename, and delete them freely. They live with your project, so the whole team gets the same toolbox.

Write inline or import a script

Type a quick one-liner in the built-in shell editor, import an existing .sh file, or just ask the agent — Verbative ships a Claude Code CLI skill so it writes and edits Mechanics for you, straight into the panel.

Free includes up to 2 Mechanics; Advanced is unlimited.

Verbative Shot · power feature

Show Claude exactly what you see. Every region, one paste.

The fastest way to give Claude visual context. Hit ⌃⌘S or the panel button and drag over whatever Claude can't see — a design you want built, a render that looks wrong, an architecture sketch to scaffold from. Keep dragging, region after region; press Esc when you're done. They're stacked into a single image on your clipboard, so one paste drops the whole picture into Claude. No screenshot files, no digging through a folder, no attaching one image at a time.

  • Drag anywhere on screen — straight to your clipboard
  • Several in a row stack into one image — paste once
  • Captured on-device by macOS — nothing is ever uploaded

Free includes 10 captures a day · Advanced is unlimited.

Verbative Shot
Drag a region → clipboard · several stack into one
⌨ ⌃⌘S — works anywhere
One image on your clipboard
1A design to buildFigma frame or mockup → “build this component”
2A render that looks wrongMisaligned, overflowing, breaks on mobile
3An architecture sketchWhiteboard or flow diagram → scaffold it

⌃⌘S · drag, drag, drag → paste once

Frequently asked

How is this different from Claude.ai’s voice mode?

Claude’s voice mode is a spoken conversation with the assistant — great for chat, but it doesn’t act on your codebase: no repo edits, no terminal commands, no tool approvals. Verbative is an agentic development extension for VS Code that drives the Claude Code CLI — the agent that actually edits your repo and runs commands in your terminal — by voice. Crucially you don’t have to flip on auto-accept and lose visibility: every permission Claude Code CLI asks for is spoken aloud with what it’s about to do, and you say “approve”, “deny”, or “explain” to act on it. Full information, you stay in the loop, no keyboard.

What does this actually do that Claude Code CLI doesn’t already?

Claude Code CLI has built-in dictation, but you have to press a key to start and stop it, and there’s no voice path for permission prompts, status checks, or aborting a run. Verbative adds the wake word, voice-driven permission approval with full spoken explanations, “update” for a spoken status check while Claude is working, and “stop claude” to abort. The keyboard becomes optional, not required.

What's Advisory Board?

An opt-in design-review panel for your ideas. When you’re adding a feature or rethinking your architecture, every prompt is reviewed in parallel by a panel of domain advisors — by default Backend, Frontend, Security & Compliance, QA, Product Manager and DevOps — before your Tech Lead session even responds, so a fresh design gets a guiding second look against each discipline’s standards. Each runs as a one-shot Haiku call, each gets its own distinct voice via Kokoro, and each only speaks when the concern is genuinely in their lane. After the Tech Lead does the work, the same panel reviews the result; if anything was missed they force exactly one revision pass, then the loop ends. The board is fully customizable: deactivate any advisor, or add your own with its own name, focus and voice — and click any advisor to see, read-only, the exact instructions it’s given. Toggle in the Verbative sidebar or say “advisory board” by voice.

How does the 14-day free trial work?

Click “Start 14-day free trial” and check out — you get the full Advanced plan (memory engine, unlimited hands-free loops, everything) free for 14 days. A card is collected at the start but nothing is charged during the trial, and Stripe emails you a reminder before the first charge. Cancel anytime before the trial ends and you pay nothing; your account then continues on Free with its daily limits.

What happens to my memory when the trial ends?

Nothing is deleted — ever. Your memories are plain, human-readable files inside your own project, and they stay exactly where they are: readable, exportable, and git-trackable. What pauses is the engine — automatic capture and recall into prompts stop until you upgrade, and the moment you do, everything resumes with the full memory your agents had already built.

Is my voice sent to your servers?

Never to ours. And with Local mode, not to anyone’s. You choose how the prompt is transcribed: Cloud mode uses Claude Code CLI’s own dictation on Anthropic’s infrastructure (we only ever see usage counts — no audio, no transcripts), while Local mode — privacy-first, available and on by default on every plan — transcribes the entire prompt on-device with whisper.cpp. Your voice never leaves your Mac. (Your pick of whisper model, tiny → large-v3, is available on every plan.) Either way, wake-word detection is always local.

What languages can I speak?

Roughly 99. Just speak — Verbative translates whatever you dictate to English on-device with whisper.cpp before it ever reaches Claude. It's always on, on every plan, with nothing to switch on. The major languages — Spanish, French, German, Italian, Portuguese, Dutch, Russian, Polish, Ukrainian, Chinese, Japanese, Korean, Hindi, Arabic, Turkish, and more — translate cleanest; lower-resource languages still work but a little less smoothly. The voice commands themselves always stay English, and on the full Large v3 model Verbative also names the language it heard.

What gets metered?

Only the Free tier — and only with daily caps: 10 hands-free loops (each successful "listen" wake counts as one), 10 Advisory Board reviews, and 10 Verbative Shot captures per day, all resetting at 00:00 UTC. On Advanced, nothing is metered, counted, or capped: it's unlimited.

Does it work without internet?

Claude Code CLI itself always needs the internet — that's Anthropic's API. What 'offline' means here is our licensing: Free has to ping our server per hands-free loop (so it goes down if we do); Advanced caches a signed license for 48 hours so our backend can be unreachable without locking you out of Advanced features.

Which platforms?

macOS only at launch. Windows and Linux are on the roadmap — vote on the docs page.

Cancel anytime?

Yes. One click in the customer portal. You keep Advanced until the end of the billing period, then drop back to the free tier with the same license.

Everything you just saw. One extension.

Voice, parallel agents, memory, and the whole toolkit — install once and talk to your code.

Get Verbative