Quick answer: Write the prompt as eight short, labelled sections: role, spoken-output rules, turn rules, detail capture, tools, escalation, three example exchanges and per-call context. Keep it under 2,000 tokens, the point past which ElevenLabs says prompts add latency and cost. Our complete eight-section template measures 778 tokens. Menus, FAQs and long workflows belong in retrieval tools, backend agents or flow nodes, not in the prompt.
How do I write a system prompt for an AI voice agent?
A voice agent’s system prompt works under three constraints a chatbot’s never meets. Vapi’s prompting guide names them: “Every token costs latency. The system prompt loads into the model’s context on every turn”; spoken replies have to be short because the caller cannot scroll back; and turn-taking replaces reading, so the prompt has to say when to speak, when to listen and when to confirm (Vapi, Voice AI Prompting Guide, read 26 September 2026). LiveKit adds a fourth for cascaded STT-LLM-TTS pipelines: “the LLM in the middle has no built-in understanding of its own position in a voice pipeline”. It will write markdown, digits and URLs unless told not to (LiveKit, Prompting guide, read 26 September 2026).
The six prompting guides we read for this page, from OpenAI (one for the Realtime API, one for GPT-Live), ElevenLabs Agents, Vapi, Retell AI and LiveKit Agents, agree on the broad shape: labelled sections, short bullet rules, a few example exchanges, explicit tool rules. The sequence below is the order we write a prompt from a blank page; each step produces one section.
Day one, first action
If you already have a prompt, count its tokens section by section before you change a word. If you are starting from scratch, copy the eight headings from the template further down and count as you fill them. The per-section count shows which section has grown, which a single total cannot. The script we used is in the next section.
- Write the role and objective (up to 150 tokens). Name the agent, say who it is talking to, and define success as two or three outcomes a call can end in: booked, callback agreed, not interested. OpenAI’s Realtime 2 guide asks for the same precision: “Replace broad guidance like ‘be helpful’ with clear trigger, action, and exception rules” (OpenAI, Prompting Realtime models, read 26 September 2026). Put the AI disclosure here too.
- Write the spoken-output rules (up to 250 tokens). Plain text only, no markdown, lists, emojis or code. Numbers, dates, money and phone numbers written the way a person says them. URLs without the scheme. No IDs or tool names read aloud. Vapi’s table is the clearest statement of the rule: $42.50 becomes “forty-two dollars and fifty cents” and 2:15 PM becomes “two fifteen in the afternoon”. On ElevenLabs, the default normalisation strategy,
system_prompt, adds these instructions to your prompt for you; the alternativeelevenlabsnormaliser runs after the LLM, which ElevenLabs rates as more reliable at the cost of “minor latency” (ElevenLabs, Prompting guide, read 26 September 2026). - Write the turn rules (up to 200 tokens). Reply length, one question per turn, what to do when interrupted, what to do on silence and on unclear audio. Give a length in sentences, not an adjective. OpenAI’s guide says “Direct answers: Use 1-2 short sentences”, Retell’s says under two sentences, LiveKit’s template says one to three. Silence needs its own rule because, in OpenAI’s words, “Voice agents tend to respond by default.” OpenAI’s fix is a no-op tool called
wait_for_userthat the model calls instead of saying “I’m here”. Vapi’s rule is “Wait 10-15 seconds, then check in once”. ElevenLabs is clear that the system prompt “does not control conversation flow mechanics like turn-taking”; that is platform configuration, and the prompt only decides what the agent says once it has the turn. - Write the detail-capture rules (up to 250 tokens). One field per turn. Ask for emails to be spelled out and read them back letter by letter. Read numbers back digit by digit. After a correction, repeat the whole corrected value. No tool call until the caller has said yes. OpenAI’s reason for digit-by-digit read-back is worth quoting: “Reading the value as a full number can hide errors.” For email addresses, our breakdown of why AI voice agents get email addresses wrong covers what the transcriber does to them before the prompt ever sees them.
- Write the tool rules (up to 400 tokens). For each tool, say when to call it, when not to, whether to confirm first, what to say while it runs, and what to do when it fails. OpenAI’s default is to call read-only tools without asking, but to “Confirm amount, target, and consequence before calling” anything that buys, cancels or pays. Its rule for the spoken line during a tool call is “Use one short sentence.” The guide also warns that if the prompt names a tool the session does not actually provide, the model “may invent a tool name or pretend it completed the action”, so make sure every tool the prompt names really exists. For slow tools, see our guide to voice agents that go silent on tool calls.
- Write escalation and limits (up to 200 tokens). When to transfer to a person, which advice the agent must not give, and a rule never to state prices, discounts or dates that a tool has not returned. Keep it short and positive: Vapi calls long “never say” lists an anti-pattern, because every banned phrase sits in the model’s active context, and recommends keeping any list to “3–5 items plus a principle clause”. A prompt is not a security control; in Vapi’s words, “the prompt is probabilistic, not deterministic”. Identity checks, consent and do-not-call enforcement belong in your server code.
- Add three example exchanges (up to 400 tokens). A happy path, an edge case and an error recovery: that is Vapi’s minimum, “Include at least three”. Keep them short and in spoken form. OpenAI’s 1.5 guide notes that “The model closely follows sample phrases” and recommends a variety rule so the same opener does not come back every turn.
- Inject per-call context as variables (up to 150 tokens). Today’s date, the caller’s name, the reason for the call and business hours, in spoken form, filled in at dispatch time rather than typed into the prompt. Vapi does this with Liquid variables and LiveKit with job metadata.
- Move everything else out. Price lists, menus, FAQs, policy documents and multi-branch procedures go into a retrieval tool, a backend agent or a flow node. OpenAI’s GPT-Live migration guide says to split an existing prompt “instead of copying it wholesale into session.instructions”, keeping conversation style in the voice prompt and moving “detailed workflows and tool-use instructions to the backend” (OpenAI, Migrate to GPT-Live, read 26 September 2026).
- Measure, then test. Count the finished prompt per section (the script is below) and check each section against its ceiling. The finish state is written down, not felt: every section under its ceiling, the total under 2,000 tokens, every tool the prompt names present in the tool list, and a test set that includes an interruption, a long silence, a spelled email, a failed tool call and a request to speak to a person. Our checklist for testing an AI voice agent before go-live turns that list into scripted calls.
The Eight-Slot Voice Prompt: a token budget for every section
The template below is our starting point, written for a callback-and-booking agent and measured on 26 September 2026 with OpenAI’s open-source tiktoken library, o200k_base encoding, counting each top-level section separately. The eight sections sum to 778 tokens, and the whole file counted in one pass also gives 778. The ceilings in the last column are our own editorial allocation, set so that they add up to exactly the 2,000 tokens ElevenLabs uses as its warning line. They are not a vendor figure.
| Slot | What goes in | What stays out | Tokens in our template | Ceiling we use |
|---|---|---|---|---|
| 1. Role and objective | Name, who the caller is, success as 2 to 3 end states, AI disclosure | Company history, mission statements | 85 | 150 |
| 2. Spoken output | Plain text, spoken numbers, phone-number grouping, URLs without scheme, no IDs aloud | Written style guides | 128 | 250 |
| 3. Turn rules | 1 to 2 sentences, one question, interruption, silence, unclear audio | Long lists of banned phrases | 104 | 200 |
| 4. Capturing details | One field per turn, spell and read back, correction loop, confirm before tool use | Validation logic (server side) | 92 | 250 |
| 5. Tools | When, when not, preamble line, confirm before writes, failure path, claim success only after success | Parameter schemas (they live in the tool definitions) | 117 | 400 |
| 6. Escalation and limits | Transfer triggers, advice limits, no invented prices, stop-calling requests | Legal text, full compliance policy | 79 | 200 |
| 7. Examples | 3 exchanges: happy path, edge case, recovery | Dozens of full transcripts | 122 | 400 |
| 8. Context for this call | Date, first name, reason for call, hours, as variables | FAQs, price lists, menus (retrieval tool) | 51 | 150 |
| Total | 778 | 2,000 |
A complete prompt uses 39% of the 2,000-token line (778 ÷ 2,000 = 0.389). That margin is the point of the exercise. Every section can grow as testing finds real failures, which is how OpenAI tells you to grow a prompt: start minimal, run evaluations, and add instructions only for behaviour that fails in testing. Note that tokenisers differ between models, so treat any count as an estimate for the model you actually run.
# Role and objective
You are Sam, a phone assistant for [Company], a [type of business] in [city].
You speak with people who asked for a callback about [service].
Success means one of three outcomes: an appointment is booked, a callback time is agreed, or the person says they are not interested.
You are an AI assistant. If anyone asks whether you are a person, say so plainly.
# Spoken output
Everything you write is converted to speech. The caller hears it and never sees it.
- Plain sentences only. No markdown, lists, headings, emojis, tables or code.
- Say numbers the way a person would: "two thirty in the afternoon", "Tuesday the fourteenth of October", "one hundred and fifty dollars".
- Read phone numbers in groups: "oh four one two, three four five, six seven eight".
- Say web addresses without "https" or "www": "company dot com dot au slash book".
- Do not read out IDs, tool names, error codes or raw data.
# Turn rules
- Keep each turn to one or two short sentences.
- Ask one question per turn, then stop and listen.
- If the caller interrupts, stop, listen, and answer what they said. Do not restart your previous sentence.
- If the caller is silent, wait. After a long silence, ask once: "Are you still there?" If there is still no answer, say goodbye and end the call.
- If you did not hear clearly, ask them to repeat. Do not guess.
# Capturing details
Collect one detail at a time: name, then preferred day, then time.
- For an email address, ask the caller to spell it, then read it back letter by letter.
- For a phone number, read it back digit by digit.
- If the caller corrects any part, repeat the whole corrected value and ask again.
- Only use a detail in a tool after the caller has said yes to the read-back.
# Tools
check_availability: use when the caller names a day. Before calling, say one short line such as "I'll check that day now."
book_appointment: use only after the caller confirms the day, time and their name. Read the booking back first and wait for a clear yes.
end_call: use after goodbye, or when the caller asks to stop.
If a tool fails, say you could not complete it, offer to try once more, and if it fails again offer a callback from a person.
Only say something is booked after book_appointment succeeds.
# Escalation and limits
- Transfer to a person if the caller asks for one, is upset, or asks about pricing, contracts or complaints.
- Do not give legal, medical or financial advice.
- Do not promise prices, discounts or dates that a tool has not returned.
- If the caller asks you to stop calling, confirm you will note it, then end the call.
# Examples
Caller: "Yeah, what's this about?"
Sam: "Hi, it's Sam from [Company], calling back about your enquiry on [service]. Is now an okay time?"
Caller: "Can you do Thursday?"
Sam: "I'll check Thursday now."
[check_availability]
Sam: "I have ten in the morning or two thirty in the afternoon on Thursday. Which suits you?"
Caller: "It's j-o-dot-lee at mail dot com."
Sam: "Thanks. That's j, o, dot, l, e, e, at mail dot com. Is that right?"
# Context for this call
Today is {{today_spoken}}. The caller's name on file is {{first_name}}.
They enquired about {{service}} on {{enquiry_date_spoken}}.
Business hours are {{hours_spoken}}.
This is the counting script. We ran it against the template above, saved as a file, to produce the numbers in the table:
import re, sys
import tiktoken
enc = tiktoken.get_encoding("o200k_base")
text = open(sys.argv[1], encoding="utf-8").read()
parts = re.split(r"(?m)^(?=# )", text)
total = 0
for part in parts:
if not part.strip():
continue
heading = part.splitlines()[0].lstrip("# ").strip()
n = len(enc.encode(part))
total += n
print(f"{heading:<28}{n:>6}")
print(f"{'TOTAL':<28}{total:>6}")
How long should a voice agent system prompt be?
Among the vendor guides we read (OpenAI, ElevenLabs, Vapi, Retell AI and LiveKit), only ElevenLabs gives a length target in tokens, and it is advice rather than a limit. ElevenLabs’ FAQ says “No universal limit exists, but prompts over 2000 tokens increase latency and cost”. OpenAI publishes a hard cap for GPT-Live. For the Realtime API, the only 16,384 figure we found, after reading its API reference, model pages, prompting guide and cost guide, is an error message a developer reported on OpenAI’s own forum.
| Platform or model | Number | What the number is | Where it is stated |
|---|---|---|---|
| ElevenLabs Agents | 2,000 tokens | Guidance: above this, prompts add latency and cost; no universal limit | Vendor prompting guide, FAQ |
| OpenAI GPT-Live | 16,384 tokens | Documented cap on session instructions | Vendor docs, Managing GPT-Live sessions |
| OpenAI GPT-Live | 500 tokens | Maximum per mid-session session.instructions.append event |
Vendor docs, same page |
| OpenAI GPT-Live | 8,192 tokens | Maximum history handed to a replacement engine once context use passes 90%, alongside the original instructions | Vendor docs, same page |
OpenAI Realtime API, instructions field |
None stated | API reference describes the field with no maximum length | Vendor API reference (Create call, Accept call, Client secrets) |
| OpenAI Realtime, gpt-realtime-1.5 | 16,384 tokens | Error text reported by a developer on 14 April 2026: 17,199 tokens rejected | OpenAI community forum, not the docs |
| gpt-realtime-1.5 | 32,000 / 4,096 | Context window / max output tokens | Vendor model page |
| gpt-realtime-2 | 128,000 / 32,000 | Context window / max output tokens | Vendor model page |
| OpenAI Realtime, 32k model | 28,224 tokens | What the context holds before the oldest messages are dropped | Vendor cost guide, Truncation |
The Realtime API reference describes instructions as the system message “prepended to model calls” and adds: “The instructions are not guaranteed to be followed by the model, but they provide guidance to the model on the desired behavior.” On the same forum thread, an OpenAI support reply dated 16 September 2026 said the documentation “does not indicate that the full model context window can necessarily be used for the initial Realtime session.instructions + tools configuration”. Design as if 16,384 tokens is the Realtime ceiling too.
Worked calculation: what a big prompt costs in call length
Size matters below any cap, because the prompt shares the context window with the call. OpenAI’s cost guide gives the inputs: caller audio costs 1 token per 100 ms and agent audio 1 token per 50 ms. A 32k Realtime model “can only include 28,224 tokens in the context before truncation occurs”, and truncation drops messages “starting from the oldest” (OpenAI, voice cost guide, read 26 September 2026). The instructions are kept, because truncation drops messages. The API reference groups tool definitions with the instructions: its optional post_instructions limit counts tokens “after instructions (which including tool definitions)”. So tool schemas take their share of the budget alongside the prompt. Our assumption for the example: in each minute of the call the caller speaks for 24 seconds and the agent speaks for 24 seconds. That is 240 caller tokens plus 480 agent tokens, 720 audio tokens a minute, before any text transcript or tool results.
| gpt-realtime-1.5, audio tokens only | 778-token prompt | 16,000-token prompt |
|---|---|---|
| Budget before truncation | 28,224 | 28,224 |
| Left for the call after the prompt | 27,446 | 12,224 |
| 10-minute call (7,200 tokens): headroom left | 20,246 | 5,024 |
| 20-minute call (14,400 tokens): headroom left | 13,046 | −2,176 (oldest turns dropped) |
| Minutes before the first turns are dropped (left ÷ 720) | about 38 | about 17 |
| Prompt tokens sent as input across 40 agent responses | 31,120 | 640,000 |
The failure is quiet. At about the 17-minute mark the 16,000-token agent loses the opening of the call, including what the caller asked for and the read-back they confirmed, and nothing errors. The last row is cost rather than memory. OpenAI’s cost guide shows instructions counted as input on every response, and says prompt caching is “best-effort and not guaranteed”. The forum developer saw the same pattern: calls with returning customers, where extra context was loaded, “would exceed the limit and the agent would lose critical rules from the end of the prompt”, and it took weeks to diagnose. On gpt-realtime-2 the window is 128,000 tokens, which OpenAI describes as “roughly 1-2 hours of dense raw audio context”, so the arithmetic loosens but does not go away.
When one prompt is no longer enough
Each row below is a published threshold or a documented behaviour, with where the excess should go instead.
| Signal | Threshold | Move the excess to | Who says so |
|---|---|---|---|
| Prompt length | Over 2,000 tokens | Specialised agents, or reference material in a knowledge base | ElevenLabs |
| Decision branches | More than 3 to 4 conditional paths | Conversation Flow, one node per step | Retell AI |
| Tools | 5 or more functions | Conversation Flow, deterministic tool calls per node | Retell AI |
| Detailed workflows on GPT-Live | Any procedure with tool use | A backend model via delegation.responses; the voice prompt keeps style and delegation rules |
OpenAI |
| Task rules in Pipecat developer messages | Any rule that must last the whole call | system_instruction, which sits outside the summarised context |
Pipecat docs and maintainer |
The Pipecat row has a paper trail. Its context-management docs say developer messages sit in the normal context and can be compressed or dropped when the context is summarised. Issue #5595 reported exactly that happening to a leading developer-role prompt. A maintainer replied that the behaviour was “working as expected. Long-lived instructions should be provided via the system_instruction”. The reporter moved the prompt, and the issue was closed on 22 September 2026 with no linked pull request; it remained closed as at 26 September 2026.
Where the vendor prompting guides disagree
The six guides were written for different model families and pipelines, and on four points their advice pulls in opposite directions; on a fifth, read-backs, they look opposed but differ only in scope. Pick per row, based on your stack, instead of merging them.
| Question | One guide says | Another says | What we do |
|---|---|---|---|
| How to emphasise a critical rule | OpenAI, gpt-realtime-1.5 guide: capitalise key rules so they stand out; ElevenLabs: append “This step is important” and repeat the 1 to 2 most important rules twice | OpenAI, gpt-realtime-2: be careful with must, only, never and always, because overuse makes the model “rigid, overly cautious” | Match the model. Capitals and repetition for older models; narrow, precisely scoped rules for reasoning models that read literally |
| Filler words | Vapi: “2–4 disfluencies per turn is a good baseline” | OpenAI: preambles should avoid “Hmm…” and “Let me think…” | No filler in the line that covers a tool call. Disfluency only for casual personas, and only after listening to it on your voice |
| Naming tools in the prompt | Retell: “Reference tools by their exact names” | Vapi: describe what a tool does rather than its resource ID, which can leak into speech | Function names in the Tools section; a spoken-output rule that never reads them aloud |
| What to say during a slow tool | OpenAI: prompt a one-sentence preamble | Vapi: configure a request-start message on the tool, “more reliable than prompting the LLM to acknowledge” | Use the platform’s tool message where it exists; prompt the preamble only where it does not |
| Reading details back | OpenAI: confirm exact identifiers digit by digit before using them in a tool call | Vapi: read back data that has to be exact (appointment times, names, email addresses), but skip read-backs for soft qualification data, which “turns the call into a form” | Read back values that must be exact; acknowledge and move on for opinions and preferences |
Spoken output fails in the pipeline, not only in the prompt
A spoken-output rule tells the model what to write; it cannot stop the pipeline speaking text that was never meant for the caller. Pipecat issue #4901, filed on 26 June 2026, captured TTS frames from a production call in which a Claude model, running without extended thinking configured, wrote its reasoning inline between <thinking> tags and the TTS read it to the caller. The reporter’s reproduction step was to “Use a non-trivial system prompt with conditional/decision-tree instructions.” The maintainer could not reproduce that: across 46 test calls with conditional prompts, the model never wrapped its reasoning in tags. The leak did reproduce “as soon as the system instruction explicitly asks the model to reason inside” thinking tags. The maintainer closed the issue on 3 July 2026, saying the alternatives were the stronger path, and a merged pull request (#976) in the pipecat-ai/docs repository references it; the issue remained closed as at 26 September 2026. The lesson for prompt writers: do not ask the model to reason inside tags unless your pipeline strips them before TTS, and check the TTS log for leaked reasoning or tags, not only the transcript. LiveKit adds that tag-based pause and emotion markup renders only in cascaded pipelines, because “realtime speech models don’t interpret tags inside LLM output”.
If the agent already ignores the prompt you wrote
If you already have a prompt and the agent drifts from it, the order of suspicion is different. First, find out whether the text the model received is the text you wrote. Truncation, summarisation, a mid-session update or a prompt that never loaded all look like disobedience. Next, check for rules that contradict each other, and for tool names in the prompt that the tool list does not contain. Only after that is it worth rewording anything. We cover that triage, symptom by symptom, in why your voice AI agent ignores its instructions.
What writing and maintaining the prompt yourself actually costs
The first version is the quick part. The ongoing cost is testing. Vapi’s guide says to validate prompt changes against “a representative test set, not single calls”, because probabilistic regressions only show up across many runs. ElevenLabs says to change one thing at a time and re-run the same failed conversations. OpenAI’s example: swapping “inaudible” for “unintelligible” improved how the model handled noisy input. So every prompt change costs a test-set run, and a set covering interruptions, silence, spelled emails, tool failures and escalation, each run several times because failures are probabilistic, quickly reaches dozens of calls. That is manageable for one agent and one script. It becomes the main job once there are several scripts, languages or campaigns, each with its own regression set.
This is the work Zian AI’s PrecisionPitch AI™ is built around: continuous split-testing of scripts and approaches, with a learning engine that tracks around 420,000 data points across more than 10,000 leads a day. By hand or on a platform, the method is the same: measure the prompt, test the change, keep what the test set proves.
Frequently asked questions
How long should a system prompt be for a voice agent?
Aim for under 2,000 tokens. ElevenLabs says in its prompting guide that no universal limit exists but prompts over 2,000 tokens increase latency and cost. OpenAI documents a hard cap of 16,384 tokens for GPT-Live session instructions in Managing GPT-Live sessions. A complete eight-section voice prompt can fit in under 800 tokens.
Should I use markdown in a voice agent system prompt?
Yes for the prompt, no for the output. LiveKit recommends Markdown headings to structure instructions, and ElevenLabs says clear section headings help the model prioritise rules. The same prompt must tell the agent to reply in plain spoken sentences with no markdown, lists, emojis or code, because a text to speech engine will read the symbols or stumble on them.
Can I reuse my chatbot prompt for a voice agent?
Not unchanged. Vapi states that a system prompt written for a text chatbot will fail in a voice conversation. A voice prompt needs reply length in sentences, one question per turn, spoken forms for numbers and dates, read-back rules for exact details, and rules for silence and interruption.
What should a voice agent say while a tool is running?
One short sentence that describes the action, such as I will check that day now. OpenAI recommends one short sentence and no more than two, and advises against filler such as let me think. If your platform can attach a spoken message to the tool itself, as Vapi does with a request-start message, use that, because it plays without waiting for the model.
How do I make a voice agent handle silence?
Give it a rule and, where the platform supports it, a tool. OpenAI suggests a no-op tool named wait_for_user that the model calls when the audio is silence, background noise or speech not addressed to it. Vapi suggests waiting 10 to 15 seconds, checking in once, and ending the call only if there is still no answer.
Is 16,384 tokens the instruction limit for the OpenAI Realtime API?
It is documented for GPT-Live. For the Realtime API, the reference describes the instructions field without a maximum, and the 16,384 figure comes from an error message a developer reported on the OpenAI community forum in April 2026. In September 2026 OpenAI support said the docs do not indicate that the full context window can be used for initial instructions and tools. Design under 16,384 either way.
Where every figure on this page comes from
| Figure | Who published it | Link | Date read |
|---|---|---|---|
| Prompts over 2,000 tokens increase latency and cost; no universal limit; normalisation strategies | ElevenLabs | Prompting guide | 26 Sep 2026 |
| GPT-Live instructions up to 16,384 tokens; 500 tokens per append; 8,192 tokens of history; 90% trigger; 128,000-token default context | OpenAI | Managing GPT-Live sessions | 26 Sep 2026 |
| Realtime instructions field with no stated maximum; optional post_instructions limit counts tokens “after instructions (which including tool definitions)” | OpenAI | API reference, Create call | 26 Sep 2026 |
| gpt-realtime-1.5: 32,000 context, 4,096 max output | OpenAI | Model page | 26 Sep 2026 |
| gpt-realtime-2: 128,000 context, 32,000 max output | OpenAI | Model page | 26 Sep 2026 |
| 28,224 tokens before truncation; 1 token per 100 ms caller audio, 1 per 50 ms agent audio; caching best-effort | OpenAI | Voice cost guide | 26 Sep 2026 |
| 1 to 2 short sentences; one-sentence preambles, two at most; 32k to 128k context; 1 to 2 hours of audio; reasoning effort low | OpenAI | Prompting Realtime models | 26 Sep 2026 |
| 16,384-token error reported with 17,199 tokens (14 Apr 2026); OpenAI support reply (16 Sep 2026) | Developer post and OpenAI support, OpenAI community forum | Forum topic 1378932 | 26 Sep 2026 |
| 1 to 2 sentences; at least 3 examples; 3 to 5 item banlists; 2 to 4 disfluencies per turn; wait 10 to 15 seconds | Vapi | Voice AI Prompting Guide | 26 Sep 2026 |
| Under 2 sentences; more than 3 to 4 conditional paths; 5 or more tools | Retell AI | Prompt Engineering Guide | 26 Sep 2026 |
| One to three sentences; tags do not render in realtime speech models | LiveKit | Prompting guide | 26 Sep 2026 |
| Developer messages may be compressed or dropped during summarisation | Pipecat | Context Management | 26 Sep 2026 |
| #5595 filed 2 Sep 2026, closed 22 Sep 2026, no linked PR; closed as at 26 Sep 2026 | pipecat-ai/pipecat on GitHub | Issue 5595 | 26 Sep 2026 |
| #4901 filed 26 Jun 2026, closed 3 Jul 2026; maintainer could not reproduce with conditional prompts (46 calls) but did when the prompt asked for reasoning inside tags; pipecat-ai/docs PR #976, merged 3 Jul 2026, references it; closed as at 26 Sep 2026 | pipecat-ai/pipecat on GitHub | Issue 4901 | 26 Sep 2026 |
| 778 tokens across eight sections; per-section counts | Zian AI, first-party measurement with tiktoken o200k_base | Method and script on this page | 26 Sep 2026 |
| 720 audio tokens per minute (24 s caller, 24 s agent) and all worked-calculation rows | Zian AI, worked example on OpenAI’s published token rates | Assumption stated on this page | 26 Sep 2026 |
| Around 420,000 data points; more than 10,000 leads a day | Zian AI (first-party claim released by the owner) | Not externally published | 26 Sep 2026 |
Build voice agents that are measured, not guessed
Zian AI builds autonomous AI sales agents across phone, SMS, email and WhatsApp in 30+ languages, with SmartReach AI™ orchestrating message, channel, timing and follow-up pacing and PrecisionPitch AI™ split-testing scripts and approaches. Zian AI is currently in partnership-application beta.