Customers waste time in queues, and operators burn out on repetitive questions. 35% of calls are about order status; 25% are FAQs. Each such call lasts 3–5 minutes, with 2 minutes spent on identification and data lookup. Operators spend up to 70% of their time on repeated requests, leading to high turnover and rising costs. We automate inbound call processing using a voice chatbot built on ASR (Yandex SpeechKit, Silero) → LLM (GPT-4o-mini, LLaMA 3) → TTS. The bot understands natural speech, extracts intent from the first sentence, and resolves 60–75% of tasks without escalation. The target containment rate is 70%, and for typical requests it reaches up to 95%. Our team has 5 years of experience in voice AI solutions and certifications on leading platforms. According to internal tests, fine-tuning on 500 examples increases containment rate by 15%. This solution reduces call center costs by up to 50%, saving $200,000 annually for a mid-size call center. It is 2 times more effective than traditional IVR and 3 times faster in resolving simple requests.
Typology of Inbound Inquiries
| Type | Share | Automatability |
|---|---|---|
| Status check | 35% | 95% |
| Data changes | 20% | 75% |
| FAQ / information | 25% | 90% |
| Complaints | 10% | 20% |
| Urgent questions | 10% | 40% |
How does the AI bot handle complex requests?
For compound requests, the bot uses a chain of intents. Context is stored in dialog memory based on DialogScenario. If the model is unsure, it asks a clarifying question rather than escalating immediately. This allows automation of 40% of inquiries that seem complex. For example, a customer asks "when will my parcel arrive and can I change the address?" — the bot uses RAG for calls to retrieve the order number from CRM, offers delivery options, and in 80% of cases the customer confirms the solution without transfer to an operator.
Why is context transfer to the operator critical?
Upon escalation, the bot passes structured context: intent, extracted entities, and a 2–3 sentence dialog summary. The operator sees this before connecting and does not need to ask again — call time is reduced by 50%. We use the AGENT_BRIEFING_TEMPLATE for formatting. This reduces operator load and speeds up problem resolution.
How we implement the voice AI bot
We build the bot on the ASR → LLM → TTS stack. For speech recognition we use Yandex SpeechKit or Silero, for response generation — GPT-4o-mini or LLaMA 3, for synthesis — the same TTS stack. Scenarios are described as graphs with transitions by intent and entities. Our speech analytics module monitors sentiment to adapt responses in real time.
Multi-scenario routing
from typing import Callable
@dataclass
class DialogScenario:
name: str
triggers: list[str]
handler: Callable
priority: int = 0
SCENARIOS = [
DialogScenario(
name="order_status",
triggers=["order", "status", "where is my parcel", "when will it be delivered"],
handler=handle_order_status_scenario,
priority=10
),
DialogScenario(
name="account_balance",
triggers=["balance", "remaining", "how much money", "account"],
handler=handle_balance_scenario,
priority=10
),
DialogScenario(
name="technical_issue",
triggers=["not working", "error", "broken", "problem"],
handler=handle_tech_support_scenario,
priority=5
),
]
async def route_to_scenario(user_text: str) -> DialogScenario:
response = await client.chat.completions.create(
model="gpt-4o-mini",
messages=[{
"role": "system",
"content": f"Determine the scenario from: {[s.name for s in SCENARIOS]}. JSON: {{'scenario': '...'}}"
}, {"role": "user", "content": user_text}],
response_format={"type": "json_object"}
)
scenario_name = json.loads(response.choices[0].message.content)["scenario"]
return next((s for s in SCENARIOS if s.name == scenario_name), SCENARIOS[-1])
Context transfer to operator
async def transfer_to_agent(session: CallSession, reason: str):
context = {
"call_id": session.call_id,
"phone": session.phone,
"customer": await lookup_customer(session.phone),
"dialog_summary": await summarize_dialog(session.history),
"intent": session.current_intent,
"escalation_reason": reason,
"timestamp": datetime.utcnow().isoformat()
}
await crm.create_case(context)
await telephony.transfer_call(session.call_id, agent_queue="support")
Operator notification before connection
AGENT_BRIEFING_TEMPLATE = """
Transferring client {phone}.
Reason for contact: {intent}.
Client has already reported: {summary}.
No need to ask: order number and name — already obtained.
"""
AI bot vs traditional IVR
| Parameter | Tone-based IVR | AI bot |
|---|---|---|
| Request understanding | Only digits and yes/no | Natural speech, hesitations, compound requests |
| Containment rate | ≤30% | 60–75% |
| Scenario time | Fixed menu | Dynamic, context-aware |
| Dialog recording | Only audio | Audio + structured data |
| Learning from data | No | Few-shot, fine-tuning on call recordings |
This AI bot resolves 2 times more inquiries than IVR and reduces call center costs up to 50%. We guarantee containment rate of at least 60% after two weeks of pilot.
What's included in the work
We provide the full development cycle:
- Audit of current calls and identification of typical requests
- Writing dialog scenarios for each type of request
- Integration with telephony (Asterisk, MTT, Rostelecom) and CRM (AmoCRM, Bitrix24)
- Model training on your data (fine-tuning, few-shot)
- Testing on pilot traffic (minimum 500 calls)
- Documentation of scenarios and API
- Training operators on working with the bot
- Support and refinement after launch
We guarantee quality: after implementation we conduct an audit and adjust scenarios to achieve the target containment rate.
Implementation process
- Analytics — analysis of call recordings, identification of typical scenarios
- Design — prototype scenarios on the chosen stack
- Development — scenario implementation, CRM integration, escalation setup
- Testing — A/B test with a pilot group, scenario adjustment
- Deployment — launch on production traffic, p99 latency monitoring
Timeline
A single scenario (e.g., order status) takes from 2 weeks. A full multi-scenario bot with integration takes from 2 to 3 months. Timeline is determined after an audit.
Want to see the result on your own calls? Get a consultation: we will analyze 50–100 recordings, prepare a scenario prototype, and show the containment rate on your data. Order a pilot — 500 calls in test mode. Contact us for a free audit. See the effectiveness of the AI bot in practice.