AI call analytics and operational automation

TL;DR. A sales manager could physically get through 5-10% of calls by hand. Nobody ever heard the rest. Incoming tickets, meanwhile, were assigned round-robin or filtered by keywords — with misses in both directions. AI closes both gaps differently: a call gets transcribed, split by speaker, and scored against the sales team's own checklist; a lead or tender gets filtered by rules and scored by a language model reading the brief for meaning, not for keyword matches. The result isn't a sample — it's full coverage. Not a dispatcher assigning by hand, but a service that routes and scores on its own.

What this is and why it matters for business

Two related but different jobs hide behind this label. The first is evaluating something that already happened: a conversation between a rep and a client that nobody would otherwise go back and listen to. The second is handling something arriving right now: a lead, a ticket, a tender listing — where the decision on priority and owner has to happen in seconds, not after a person works through the whole list. Either way, a language model takes on work there was never enough human time for, and it does it for every single item in the stream, not a sample of it.

The difference shows up in the numbers. A sales manager could physically get through 5-10% of calls — fifteen to twenty minutes of manual work per call: listen, match it to the deal stage, write up feedback. A system doesn't hit that ceiling. It scores 100% of calls, and the result lands in the Bitrix24 deal card in seconds of machine time instead of minutes of a person's.

How it actually works, mechanically

Two related but distinct pipelines live under this label — one parses a conversation that already happened, the other decides what to do with something new arriving.

Scoring a call: transcription → diarization → scoring

1. Transcription. The recording gets turned into text. This step is the foundation for everything after it: background noise, overlapping speakers, or a bad connection all degrade accuracy, and that's worth measuring in a separate pass against reference transcripts — not assumed away.
2. Diarization. The text gets split by speaker — where the rep is talking, where the client is. Skip this step, and scoring can't tell who actually broke the script or failed to lock in a next step on the deal.
3. Scoring against a checklist. The transcript, along with deal context like the funnel stage, goes to a language model that scores the conversation against a rubric the sales team wrote itself. The final score shouldn't come straight from the model's own self-report: it gets anchored to the range the model named and backed by quotes from the transcript — otherwise the score for the same unchanged call drifts from one run to the next.

Handling tickets: rules + LLM scoring

1. Collection. Tickets, listings, or leads flow in from different sources — a website form, a messenger, a tender platform — and each source usually needs its own adapter for the data format.
2. Rules and weights. Part of the decision gets made with no model involved at all: a concurrent-load cap filters out operators who are already full, and a competence-weight table for each operator-source pair decides who fits a given ticket best.
3. LLM scoring for meaning. Where keyword filtering misses — "modernization" could mean anything from swapping out equipment to rolling out computer vision — a language model reads the full brief and scores it against a profile of the work, not a list of terms.

Where it applies

• 100% call coverage instead of spot-checking — feedback for the rep on every conversation, not a random 5-10% sample.
• Automatic ticket routing by operator competence and current load — no dispatcher, no queue forming at one strong specialist while everyone else sits idle.
• Scoring leads and tender listings by what the brief actually says — instead of a daily manual scan of dozens of postings looking for the handful that fit.

The common thread: a regular, repetitive stream of incoming items — calls, tickets, listings — where the scoring criteria can be written down explicitly, as a checklist, a rubric, or a work profile.

Limitations

There's no black box here. Neither call scoring nor automated ticket scoring works without tuning to the specific process — here's what's worth knowing upfront.

• Transcription and diarization accuracy depends on recording quality. Background noise, overlapping speakers, a bad connection — transcription accuracy drops, and scoring inherits that error. Transcription accuracy is worth measuring separately from scoring accuracy, not folded into one number.
• The methodology has to be formalized upfront. The model scores a call or a ticket against a checklist, rubric, or work profile. If those criteria don't exist in explicit form, formalizing them becomes a separate step before rollout — in our experience, not a byproduct of the build.
• The model's self-reported score isn't reliable on its own. Ask a model directly to "score this 0 to 10," and the spread between runs on the same unchanged call is noticeable. The final score needs to be anchored to a range and backed by quotes from the text, not taken as whatever number the model names first.
• LLM scoring cuts down misses — it doesn't guarantee none happen. On an unusually worded brief or an edge-case ticket, the model can get it wrong the same way an inattentive person would. Calibrating against real examples before going to production is how you catch those cases early, not a box to check for a report.

How we've built this

• Call analytics in Bitrix24: AI scoring for 100% of sales conversations — WhisperX for transcription, pyannote for diarization, a local LLM scoring against 7 funnel stages with hard guardrails for a missed next step. Inference runs on the client's own GPU, recordings never leave the company's perimeter.
• Automatic ticket routing: a mini-CRM with operator competence weights — weighted random distribution across operator-source pairs with a concurrent-load cap, no dispatcher. Source code is open.
• AI scoring for tenders and leads — from 80-120 postings a day down to 3-5 relevant ones in Telegram, the brief scored 0-10 by a language model with prompt caching to keep the cost of a daily run under control.

What it costs and how long it takes

A pilot for call analytics or ticket-processing automation for a specific process starts at 200,000 RUB, 1–2 months. That covers formalizing the scoring methodology if it doesn't exist yet, building the pipeline, and integrating it into the system your team already uses — Bitrix24, Telegram, or a standalone interface. The exact estimate depends on the volume of the stream and how complex the scoring criteria are, and gets worked out during the audit stage.