Composer

Open it from Composer at the top of the sidebar, from the command palette (⌘K), or with the Composer button on an agent’s page. The button starts a thread about that agent.

You can ask things like:

• “Walk me through building an agent for my dental clinic that books check-ups.”
• “Diagnose recent call failures.”
• “Review call analytics for the week.”
• “Make the reminder agent greet in Hindi and attach the FAQ knowledge base.”
• “Call +91 98123 45678 with the reminder agent.”
• “Let me talk to the front desk agent.” (a test call right in the chat)
• “@create-agent Build a Hinglish receptionist for my clinic.” (follows the create-agent skill)

What it can do

Composer works through the Vaakyo API as you, in the workspace you have open, with your role. If your role can’t do something (a viewer can’t edit agents, for example), Composer can’t either. Every change it makes is recorded under your name with “via Composer”, and agent changes are saved as new versions like any other edit.

Resource	Read	Create	Update	Delete	Run	Publish
Agents	list, get, versions	create, duplicate	edit, restore a version	delete		put live or pause
API tools					send a test request
Phone numbers	list		connect to an agent
Calls	list, details, timeline			cancel or hang up	place a call
Batches (campaigns)	list, details	create from contacts	pause	cancel	resume
Knowledge bases	list, details, search	create	add text or a web page	delete
Webhooks	endpoints, deliveries	add an endpoint	edit	delete	send a test ping
Analytics	stats, CSV export				test post-call analytics
Skills	list, read, usage	write a skill	edit or improve a skill

Starting a test call in the chat is a Run on Calls. Composer never sees webhook signing secrets.

Test calls in the chat

Ask Composer to let you talk to an agent (“test the reminder agent”, “let me talk to it”). It shows a Test call card for that agent in the conversation. Press Start call to talk with your microphone, the same browser call as Test in browser on the agent’s page. Nothing is dialled until you press Start.

While the call runs, an Active call panel floats above the message box (a bar above it on phones). It shows the agent, a timer, the live transcript, mute, minimise and Hang up. Only one test call runs at a time. Leaving the page ends it, and the console asks first.

When the call ends, the card shows how long it lasted and a View call link to the call’s transcript, recording and timeline. Review this call asks Composer to read the call (get_call, get_call_events) and say what went well, what went wrong and what to change. You can also ask later: “check my last call”.

Test calls cost credits per second like any call, and need a role that can place calls.

Skills

A skill is a set of written instructions, like a SKILL.md, that Composer follows when you mention it. Type @ in the message box to pick a skill (agents are listed too). Picked skills show as chips above your message. The message keeps the @slug, and the answer is shaped by the skill. Each message can use up to 5 skills.

Vaakyo ships built-in skills, each a checklist that uses Composer’s tools:

Skill	Use it to
@create-agent	build any agent end to end
@appointment-booking-agent	build an agent that books, moves or cancels appointments
@lead-qualification-agent	qualify leads on inbound or outbound calls
@reminder-and-confirmation-agent	remind and confirm with per-contact {variables}
@customer-support-agent	answer support calls from a knowledge base
@hinglish-voice-agent	set up Hindi or Hinglish voice, transcription and prompt rules
@write-voice-prompt	write or rewrite a prompt for spoken conversations
@debug-call-failures	find and explain failed or short calls
@review-call-analytics	review volume, outcomes, duration and cost
@set-up-campaign	launch an outbound campaign
@knowledge-base-setup	create, fill and attach a knowledge base
@extraction-fields	design typed post-call extraction fields

Open Skills in the threads column, or from the + menu in the message box, to manage them:

• New skill: write it (name, one-line description and Markdown instructions, with a preview), paste a whole SKILL.md, or upload a .md file (up to 64 KB). The frontmatter’s name: and description: are used, as in Claude skills. A skill can be up to 20,000 characters. Its @slug is made from the name and is unique in the workspace.
• Ask Composer to write one: Composer asks what the skill should cover, then saves it (create_skill, which follows your approvals).
• Customise a built-in skill: your workspace gets its own copy under the same @slug, labelled “Customised from built-in”. Other workspaces keep the built-in. Reset goes back to the built-in. Duplicate makes a new skill from any skill.
• History: every change is kept as a version, whether you or Composer made it, with what changed. Compare an old version with the current one and Restore it.
• Each skill shows how often it was used and when.

Skills that improve

When a request used a skill and you corrected Composer (“no, always use a female voice”) or a step failed and was fixed, Composer offers to update the skill. It never rewrites a skill on its own: the change goes through improve_skill, which follows your approvals. The approval card shows the change as added and removed lines. Improving a built-in skill saves your workspace’s customised copy and never changes the built-in. Improve with Composer on a skill asks Composer to review it against your recent threads that used it and propose changes.

Reading skills needs the same access as Composer. Creating, editing, restoring and deleting them need a role that can edit agents (agents.edit). Every change is recorded.

Threads

Each conversation is a thread. Threads belong to you: other members of the workspace don’t see yours. The first message names the thread, and you can rename or delete it from the thread list. Deleting a thread removes the conversation only. Changes Composer made stay.

Each message runs at most 8 steps (model calls). If Composer stops at the limit, say “continue”.

When Composer needs you to choose (which agent, which voice), it asks with a card of options: click one (or press its letter) or type your own answer, and your answers go back as your next message. Messages you send while Composer is busy, or while an action waits for approval, wait in the queue above the message box and go out in order once it is free; you can edit or remove them there. Long things Composer writes (a system prompt, a skill, a report or an export) appear as cards you can copy, download or open full screen.

Streaming answers

Answers appear as Composer writes them, and each tool step shows up the moment it starts and again when it finishes. Stop (the button that replaces send while an answer streams) stops following the answer in this tab. What Composer already started still finishes and is saved, and the thread shows it when it does. Closing the page works the same way: the answer is complete when you come back, and another tab sees it grow.

The console streams with Server-Sent Events. Each request has a JSON form that answers once the turn has ended, and a streamed form:

JSON	Streamed
POST /api/composer/threads/{id}/messages	POST /api/composer/threads/{id}/messages/stream
POST /api/composer/threads/{id}/steps/{step_id}/approve	POST .../steps/{step_id}/approve/stream
POST /api/composer/threads/{id}/steps/{step_id}/reject	POST .../steps/{step_id}/reject/stream

A streamed request is checked before it starts, so a refusal is an ordinary JSON error: 402 (no credits), 403 (Composer is off), 404 (no such thread), 409 (Composer is busy on the thread, or an action is waiting), 422 (unknown skill). Once it starts, the answer is text/event-stream with these events, in order:

Event	Data
message	thread, your message user (null for an approval), and the answer message as it stands.
text	{"delta": "..."} to add to the answer, or {"text": "..."} to replace it (rare: a model call that was retried).
reasoning	The model’s thoughts, when the model shares them (Gemini): {"delta": "..."} or {"text": "..."} like text. Kept on the message as reasoning (with reasoning_ms), never in its text.
step	{"step": {...}}, a tool step each time it changes: queued, running, done, error, pending (waiting for approval) or rejected.
status	{"status", "error"} of the answer: working, awaiting_approval, done or error.
usage	{"usage": {...}}, the answer’s usage after each model call.
done	The thread and its messages, exactly what the JSON form returns. The last event.
error	{"status", "detail"} if the stream itself failed. The answer may still finish: read the thread.

A comment line (: keep-alive) arrives every 15 seconds while nothing else does, and responses carry Cache-Control: no-cache and X-Accel-Buffering: no. If you put your own proxy in front of Vaakyo, turn response buffering off for these paths. Like the rest of Composer, they are for the console only.

Approvals

Reading never needs approval. For everything else, the approvals menu under the message box sets what Composer may do on its own in the current thread:

Mode	What happens
Ask for approval (default)	Composer asks before it creates, updates, deletes, runs or publishes anything.
Skip some approvals	Creating runs without asking. Updates, deletes, runs and publishing still ask.
Skip all approvals	Every action runs without asking, except the ones below.
Custom · By resource	Choose Ask or Allow for each resource and action (the table above). Anything you leave out asks.

Some actions always ask, in every mode: deleting or cancelling anything, placing a real phone call (place_call), starting or resuming a campaign (create_batch, resume_batch), connecting a phone number (connect_phone_number), and creating, changing or testing a webhook. They can’t be undone, cost money or send data outside Vaakyo, and Composer reads text it doesn’t control (call transcripts, knowledge pages, shared agents) that could try to steer it, so a person always confirms them. Browser test calls follow your mode.

Composer is for people who can build: it needs the agents.edit permission (developer, admin or owner). Viewers don’t see it, and the API answers 403.

When an action needs approval, Composer pauses and shows a card with exactly what it will send. Approve runs it, and Composer carries on. Reject tells Composer you declined, and it continues without that action. A new message can’t be sent while an action is waiting (409); the console queues it until you decide.

Pricing

Composer is billed from your workspace’s prepaid credits, per model call, at a price per million input and output tokens set by the platform (a fixed price, or the price of Composer’s model on Vaakyo’s rate card). Every charge is a ledger row of kind composer in Billing.

Each answer shows what it cost and the tokens the model reported, for example ₹0.78 · 3 model calls · 28,287 input (12,000 cached) · 605 output · 120 thinking. Hover it to see each model call. Every model call sends the whole conversation so far, with tool results, so input adds up across the calls of one answer.

• Input is everything sent to the model. Cached is the part the model’s provider read from its cache. It is charged at the input price.
• Output is the answer and its tool calls.
• Thinking is the model’s reasoning, when the provider reports it apart. It is charged as output.

The thread’s total, next to its title, is the sum of its answers.

If the balance is zero or below, Composer refuses new messages with 402 and asks you to add credits. If credits run out partway through an answer, it stops after the current step.

Actions Composer takes cost what they always cost. A phone call it places is charged like any other call.

Turning Composer off

Composer is on for every workspace by default. The Vaakyo team can turn it off for a workspace. It then disappears from the sidebar and the command palette, and its API answers 403 with composer is turned off for this workspace.

Composer is a console feature. API keys and connected MCP apps can’t use it. To drive Vaakyo from your own assistant, use the MCP server.