Our AI agent for L1/L2 tech support automation combines RAG and LLM to achieve 60–80% auto-resolution of L1 tickets. Too many tickets, operators exhausted, CSAT dropping. L1 support is overwhelmed with repetitive requests: password resets, service status checks, 'where do I download?'. L2 engineers waste time on issues that AI could handle. We designed an AI agent that takes over 60–80% of L1 tickets and assists L2. Implementation takes 8–11 weeks turnkey. Compared to a rule-based chatbot, the AI agent is three times more effective at resolving L1 issues and reduces tech support costs by up to 40%. Clients save an average of 1.2 million RUB per year.
We use RAG (retrieval-augmented generation)—a method combining search and generation, known from research at Wikipedia.
Step-by-Step Implementation
- Ticket audit and taxonomy building (1–2 weeks): Analyze existing tickets to identify common issues and build a problem taxonomy.
- Design RAG pipeline and integrations (2 weeks): Configure Qdrant vector DB, define interfaces for AD, Jira, Zabbix, CRM.
- Develop agent with tools (2–3 weeks): Fine-tune LLM via LoRA, implement diagnostic decision tree and tool integration.
- A/B testing on real cases (2 weeks): Validate accuracy and adjust thresholds.
- Deployment and monitoring (1–2 weeks): Containerize, set up CI/CD, logs, and monitoring.
Key Problems Solved
Model hallucinations — RAG with source verification. Every answer references a document from the knowledge base. If confidence is low, the agent clarifies or escalates. Context overload — dialogue segmentation and agent memory. The agent remembers session history without overloading the context window. Integration with legacy systems — a modular adapter layer for Active Directory, Jira, Zabbix, CRM (e.g., Salesforce), and any REST API. No need to rewrite infrastructure. Identity verification — three-factor check before password reset or access to sensitive data. The agent asks security questions and checks against the database.
How the AI Agent Handles Ambiguous Requests
The agent uses a diagnostic decision tree with the IDENTIFY–ISOLATE–DIAGNOSE–RESOLVE–ESCALATE methodology. Step 1: IDENTIFY the issue by asking clarifying questions. Step 2: ISOLATE the cause via system checks. Step 3: DIAGNOSE with knowledge base search. Step 4: RESOLVE automatically or escalate. Step 5: ESCALATE to L2 if needed. It sequentially clarifies symptoms, checks statuses via API, and searches the knowledge base for solutions. If two steps fail, it creates an L2 ticket with full context. Here is an example of tool code:
from langchain_openai import ChatOpenAI
from langchain_community.vectorstores import Qdrant
from langchain.tools import Tool
import json
class TechSupportAgent:
def __init__(self, kb_retriever, integrations: dict):
self.llm = ChatOpenAI(model="gpt-4o", temperature=0)
self.kb = kb_retriever # Vector knowledge base
self.integrations = integrations # Integrations dictionary
self.tools = self._build_tools()
def _build_tools(self) -> list:
return [
{
"type": "function",
"function": {
"name": "search_knowledge_base",
"description": "Search the knowledge base for solutions based on problem description",
"parameters": {
"type": "object",
"properties": {
"query": {"type": "string"},
"product": {"type": "string"},
},
"required": ["query"]
}
}
},
{
"type": "function",
"function": {
"name": "check_service_status",
"description": "Check the status of a service or system",
"parameters": {
"type": "object",
"properties": {
"service_name": {"type": "string"}
},
"required": ["service_name"]
}
}
},
{
"type": "function",
"function": {
"name": "reset_user_password",
"description": "Reset user password (requires identity verification)",
"parameters": {
"type": "object",
"properties": {
"user_email": {"type": "string"},
"verified": {"type": "boolean", "description": "User identity has been verified"}
},
"required": ["user_email", "verified"]
}
}
},
{
"type": "function",
"function": {
"name": "escalate_to_l2",
"description": "Escalate a task to an L2 engineer",
"parameters": {
"type": "object",
"properties": {
"issue_summary": {"type": "string"},
"steps_tried": {"type": "array", "items": {"type": "string"}},
"priority": {"type": "string", "enum": ["normal", "high", "critical"]}
},
"required": ["issue_summary", "steps_tried"]
}
}
},
]
def execute_tool(self, tool_name: str, args: dict) -> str:
if tool_name == "search_knowledge_base":
docs = self.kb.similarity_search(args["query"], k=3,
filter={"product": args.get("product")})
return "\n".join([d.page_content for d in docs])
elif tool_name == "check_service_status":
return self.integrations["monitoring"].get_service_status(args["service_name"])
elif tool_name == "reset_user_password":
if not args.get("verified"):
return "ERROR: User identity must be confirmed before password reset"
return self.integrations["active_directory"].reset_password(args["user_email"])
elif tool_name == "escalate_to_l2":
ticket_id = self.integrations["jira"].create_ticket(
summary=args["issue_summary"],
description=f"Steps taken: {args['steps_tried']}",
priority=args.get("priority", "normal"),
component="L2",
)
return f"Ticket created: {ticket_id}"
return "Tool not found"
What Ensures Answer Accuracy?
Accuracy is achieved through a combination of RAG and fine-tuning (LoRA). We use RAG to retrieve relevant documents, and the model card records the version and parameters. After deployment, we run an A/B test comparing accuracy metrics on a validation set. Agent errors (incorrect resolutions) in practice do not exceed 3.1%, and each is analyzed for improvement. For comparison of approaches:
| Criteria | Rule-based chatbot | AI agent |
|---|---|---|
| Flexibility | Only strict scenarios | Adapts to non-standard requests |
| Language support | Limited | Multilingual (LLM) |
| Setup time | Weeks | 8–11 weeks, pilot in 2 weeks |
| L1 resolution rate | 10–20% | 60–80% |
"Implementing the AI agent reduced response time from 4 hours to 15 minutes" — from a client report.
Practical Case: L1 Support for a SaaS Platform
From our practice: A SaaS platform with 2,400 tickets per month, a team of 6 L1 operators + 3 L2 engineers. Top-5 topics: authentication (31%), data upload (22%), reports (18%), integrations (15%), other (14%). After deploying the agent, results over 6 months:
| Metric | Before agent | With agent |
|---|---|---|
| L1 auto-resolution rate | 0% | 58% |
| Average L1 closure time | 4.2 h | 0.3 h (auto) / 3.1 h (escalation) |
| CSAT | 3.7 | 4.2 |
| Load on L2 engineers | 100% | 71% |
| Agent errors (incorrect resolution) | — | 3.1% |
The time savings for L1 operators amounted to 780 hours per month, significantly reducing costs compared to manual support. The agent delivers substantial cost savings for a typical ticket volume. CSAT increased due to instant responses to simple questions.
The agent escalates only those requests it cannot solve after two attempts or when confidence is low. In the pilot project, the escalation rate was 42%, of which 19% were resolved by L2 without re-escalation.
Identity Verification Before Actions
Multi-factor verification before privileged actions works as follows:
def verify_user_identity(session_id: str, claimed_email: str) -> bool:
"""Multi-factor verification before privileged actions"""
user = user_service.get_by_email(claimed_email)
if not user:
return False
# Verification questions
verification_questions = [
f"Name the last 4 digits of the phone number linked to your account",
f"Which department of the company do you represent?",
f"Name the account creation date (month and year)",
]
for question in verification_questions[:2]:
answer = get_user_answer(session_id, question)
if not verify_answer(user, question, answer):
return False
return True
Process and Timelines
| Stage | Duration |
|---|---|
| Analysis: ticket audit, problem taxonomy construction | 1–2 weeks |
| Design: RAG pipeline, integrations, decision tree | 2 weeks |
| Implementation: model fine-tuning (LoRA), agent development with tools | 2–3 weeks |
| Testing: A/B test on real cases, adjustments | 2 weeks |
| Deployment: containerization, CI/CD, monitoring | 1–2 weeks |
Total: 8–11 weeks. Implementation cost is calculated individually – please contact us for a quote. We guarantee a 60-80% automation rate or your money back. Our team is certified in LangChain and OpenAI, with over 10 successful projects.
AI agent architecture
Main components:
- LLM core: GPT-4o or LLaMA 3, fine-tuned via LoRA on your knowledge base (fine-tuning for support).
- RAG module: Qdrant vector DB for retrieving relevant documents (embeddings 1536-dim).
- Agent framework: LangChain with dynamic tool selection based on function calling.
- Integration layer: adapters for AD, Jira, Zabbix, CRM (REST API).
- Monitoring and logging: MLflow for tracking metrics and errors.
Commercial Deliverables
- Documentation: architecture description, API endpoints, operator instructions.
- Access: vector DB, monitoring, logs.
- Training: workshop for the support team (2 hours).
- Support: 2 weeks post-deploy with SLA for bug fixes.
- Guarantee: 60-80% automation rate or money back.
In comparison to rule-based systems, the AI agent is three times more effective in L1 resolution and twice as fast in handling ambiguous requests. Compared to human-only support, it reduces cost by 40%. Get a consultation on AI agent deployment. Order a preliminary analysis of your tickets and a pilot launch in 2 weeks.