AI-Powered Inbound Request Processing Automation
Our client — a marketplace with 500+ operators — was drowning in 50,000 daily inquiries. Manual sorting took up to 15 minutes, 30% of requests went to the wrong department, and SLA deadlines were systematically missed. We proposed automating classification and routing using an LLM. Within three months, the average response time dropped from 12 minutes to 40 seconds, and the load on the first line decreased by 60%.
Why LLM Classification Is Faster and More Accurate Than Humans?
An LLM processes requests in 1.2 seconds (p99 latency) — 12 times faster than an operator. At the same time, routing accuracy reaches 98% compared to 85% for humans. LLM processing is extremely cost-efficient, making automation economically viable for volumes starting from 500 inquiries per day. AI pays for itself in 2–3 months by reducing personnel costs.
How Is the Omnichannel Architecture Designed?
The architecture is built on the Unified Orchestrator pattern, which abstracts communication channels and passes requests through a common pipeline. Each channel (voice, chat, email) has its own processor adapter that transforms raw data into a unified IncomingRequest format.
Detailed implementation of processors
from abc import ABC, abstractmethod
from dataclasses import dataclass
@dataclass
class IncomingRequest:
id: str
channel: str
raw_content: str
metadata: dict
customer_id: str = None
class RequestProcessor(ABC):
@abstractmethod
async def process(self, request: IncomingRequest) -> dict:
pass
class UnifiedRequestOrchestrator:
def __init__(self):
self.processors = {
"voice": VoiceRequestProcessor(),
"chat": ChatRequestProcessor(),
"email": EmailRequestProcessor(),
}
self.classifier = RequestClassifier()
self.router = RequestRouter()
async def handle(self, request: IncomingRequest) -> dict:
classification = await self.classifier.classify(request)
priority = self.calculate_priority(request, classification)
return await self.router.route(request, classification, priority)
AI Request Classifier
We use an LLM with a 128K-token context window as the core — sufficient for analyzing long emails and conversation history. The model operates in structured output mode: it returns a JSON with fields intent, urgency, sentiment, entities. This allows the result to be directly passed to the routing system without post-processing.
CLASSIFICATION_SCHEMA = {
"type": "object",
"properties": {
"intent": {
"type": "string",
"enum": ["order_inquiry", "complaint", "technical_support",
"billing", "general_info", "cancellation", "compliment"]
},
"urgency": {"type": "string", "enum": ["critical", "high", "medium", "low"]},
"sentiment": {"type": "string", "enum": ["positive", "neutral", "negative", "angry"]},
"entities": {
"type": "object",
"properties": {
"order_id": {"type": "string"},
"product_name": {"type": "string"}
}
},
"summary": {"type": "string"},
"requires_human": {"type": "boolean"}
}
}
async def classify_request(text: str) -> dict:
response = await client.chat.completions.create(
model="gpt-4o-mini",
messages=[{
"role": "system",
"content": f"Classify the customer request. JSON according to schema."
}, {"role": "user", "content": text}],
response_format={"type": "json_object"}
)
return json.loads(response.choices[0].message.content)
Setting Up SLA Prioritization
SLA rules are defined in a matrix: a combination of intent + sentiment gives a base priority, and a VIP flag doubles the response speed. Critical inquiries (complaint + negative) land in a queue with a maximum wait time of 60 seconds. All rules are configured via a config file and reloaded on the fly without restarting the service.
PRIORITY_RULES = {
("critical", "angry"): {"score": 100, "max_wait_sec": 60},
("high", "negative"): {"score": 80, "max_wait_sec": 180},
("medium", "neutral"): {"score": 50, "max_wait_sec": 600},
("low", "positive"): {"score": 20, "max_wait_sec": 1800},
}
def calculate_sla(intent: str, sentiment: str, is_vip: bool) -> dict:
base = PRIORITY_RULES.get((urgency, sentiment),
{"score": 40, "max_wait_sec": 900})
if is_vip:
base["score"] += 30
base["max_wait_sec"] //= 2
return base
Handling Rare Scenarios
Even with minimal labeling (100–200 examples), the model generalizes common patterns. For rare intents, we use few-shot learning with retrieval — we pull similar cases from a ChromaDB vector database and add them to the prompt. If the model's confidence is below a threshold of 0.7, the request is forwarded to an operator with a suggested response. This strategy yields 98% accuracy even on the long tail.
Quality Evaluation Metrics
We track precision, recall, and F1 for each intent, as well as processing time and escalation rate. Weekly validation on a fresh sample is conducted — if accuracy falls below 95%, retraining is triggered. All metrics are available in a Grafana dashboard.
| Metric | Operator | AI System |
|---|---|---|
| Routing accuracy | 85% | 98% |
| Average response time | 12 min | 40 sec |
| Escalation rate | 30% | 2% |
Schedule a free diagnostic of your request flow — we'll show you the savings AI can bring.
Implementation Process
- Analytics — audit of current flows, collection of labeled cases.
- Design — model selection, classification schema design, CRM integration.
- Implementation — development of processors, classifier, router; SLA configuration.
- Testing — A/B test on 10% of the flow, verification of accuracy and latency.
- Deployment — production rollout, monitoring, operator training.
| Stage | Duration | Key Artifacts |
|---|---|---|
| Analytics | 1–2 weeks | Channel report, intent matrix |
| Design | 1 week | Architecture, chosen model, routing scheme |
| Implementation | 2–3 weeks | Code for processors, classifier, router |
| Testing | 1 week | A/B test report, SLA metrics |
| Deployment | 1 week | Monitoring, documentation, training |
What's Included
- Development — source code of all components, Docker images, CI/CD pipeline.
- Documentation — architectural, API specification (OpenAPI), operator's guide.
- Access — to repository, monitoring dashboards (Grafana), cloud infrastructure.
- Training — 2–3 workshops for the operations team.
- Support — 3 months of warranty maintenance (bug fixes, consultations).
Estimated Timelines
Basic system (classifier + router) — from 2 to 3 weeks. Full omnichannel solution with integration, SLA, and monitoring — from 2 to 3 months. The cost is calculated individually.
We have implemented more than 50 similar integrations, with 5+ years in industrial AI. If you want to estimate the savings on your flow — contact us: we'll send a case calculator within 1 day. Get a consultation on your case — we'll tell you how to reduce support load by 60%. Wikipedia: Large language model