How do AI agents handle ticket classification in enterprise environments?

AI agents classify incoming tickets by mapping each request to predefined intents, then extracting key fields: identifiers, context, request parameters, from the ticket content. When data is missing, the agent retrieves it from internal sources autonomously. The agent's reasoning trace is exposed in the UI for full auditability. Human operators review and approve proposed actions rather than performing the classification themselves.

What is human-in-the-loop in AI ticket management?

Human-in-the-loop means the AI agent handles triage, classification, and action proposal, while a human operator reviews and approves the outcome at the end of the process. The human can inspect the agent's full reasoning, edit proposed actions, and interact with the agent directly. This shifts effort from manual investigation to supervised validation, preserving control without sacrificing speed.

What tech stack is used to build an AI classification agent?

A production-ready AI classification agent can be built with NestJS (TypeScript) for the backend, LangChain or LangGraph for agent orchestration, and Claude or ChatGPT as the language model. For diagnosis workflows requiring knowledge retrieval, Qdrant works well as a vector database. The frontend can be implemented in Angular with a dedicated agent interaction interface.

Can AI agents reduce ticket resolution time in utility companies?

Yes. In a real deployment for a utility industry client, AI agents handling classification, data extraction, and diagnosis reduced manual triage effort significantly. The full implementation — including POC development, testing, and knowledge base integration — was delivered approximately twice as fast as originally projected, establishing a reusable architecture template for future workflows.

Building AI agents for classification and diagnosis

At the beginning of 2026, we began developing several AI-driven POCs for a customer that manages a high volume of end-user requests in the utility industry. The goal was to accelerate ticket resolution while preserving enterprise requirements such as control, traceability, and predictable outcomes. The concret solution was building AI agents for classification and diagnosis.

Every ticket required manual review, classification, enrichment with missing data, and routing to the appropriate resolution flow. While reliable, the process is heavily dependent on human triage and investigation. As the volume increased, maintaining response time and quality required a proportional increase in operational effort.

This led to a practical question: how much of this workflow could be structured so that an AI agent could handle it reliably?

We started by building the first POC.

AI POC for classification and data extraction

One of the POCs focused on classification and data extraction. Each incoming request needed to be mapped to one or more predefined intents. Once classified, the agent extracted the key fields required to determine the next step (e.g., identifiers, context, request parameters). Some of this information was explicitly present in the request. Other details were missing and had to be inferred or retrieved from internal sources.

The backend was implemented in NestJS (TypeScript). Agent orchestration was handled through LangChain/LangGraph to coordinate tool usage, decision points, and validation steps. For the language models, we evaluated both ChatGPT and Claude.

Beyond the technical stack, the critical architectural question was how much autonomy the agent should have. The agent needed sufficient capability to autonomously identify mandatory data points and retrieve missing context when required. At the same time, we constrained access to tools to keep outcomes predictable, measurable, and auditable.

The agent’s reasoning for tracing and retrieving data was exposed in the UI, enabling full transparency and auditability.

The final setup allowed the agent to classify requests, extract required data, and propose the appropriate resolution flow.

Human-in-the-loop as a governance layer

“The human is no longer required to analyze the user’s problem or search for identification details. The AI agent proposes all necessary actions to resolve the case. The human simply reviews and approves or declines them at the end of the AI process. They can also inspect all the information used by the AI during its reasoning process, edit action cases, and even chat live with the AI agent.” Cristi, Software Developer

This shifted the effort from manual triage and case analysis to supervised validation.

To monitor efficiency and cost behavior, we evaluated both a SaaS provider and a self-hosted open-source setup, assessing performance, operational stability, and cost control.

Human-in-the-loop as a governance layer for AI Agent

AI POC for diagnosis and recommendations

We extended the approach with a second AI agent focused on troubleshooting: diagnosing errors in existing applications and recommending actionable steps for resolution based on a centralized knowledge base.

Errors were ingested from a database and surfaced through a dedicated diagnostic interface. While we reused the same core stack, the reasoning pattern was fundamentally different.

Instead of mapping requests to intents, the agent had to diagnose root causes and recommend precise solutions based on a centralized knowledge base aggregated from multiple sources.

The search approach was hybrid. It combined semantic retrieval with structured keyword-based matching across multiple data sources. In many cases, the agent performed multi-hop retrieval, iterating through several retrieval and reasoning steps before reaching a final recommendation.

Qdrant was used as the vector database to index the centralized knowledge base and supporting files.

Compared to the first POC, this solution reduced investigation time by providing structured, evidence-based root-cause recommendations from the centralized knowledge base. Users could interact directly with the agent, apply remediation steps, and resolve issues without unnecessary escalation.

Feedback integration and knowledge accumulation

After implementing classification and diagnosis, we introduced feedback as part of the system.

At the end of the process, users could rate the proposed solutions and provide feedback. Based on this input, the agent could request additional context when needed and generate candidate solution paths for similar issues.

When new information was validated, the system automatically generated draft documents and stored them in the knowledge base pending administrative approval. Administrators could also initiate new conversations to deliberately enrich the knowledge base with additional documented error resolutions.

This closed the loop between resolution and knowledge accumulation and ensured that the system improved with usage, reducing recurring investigative effort and increasing recommendation accuracy over time.

AI across the development lifecycle

AI was not limited to runtime features.

From the moment we received the requirements, we used AI to analyze and refine them. The goal was to improve clarity and completeness before implementation started.

The customer provided mockups in Figma.

“We used Copilot and an MCP Server for Figma to implement the design directly from the mockups, which we later improved. We also integrated Playwright for automated testing, ensuring everything remained stable and continuously validated throughout development.” Andrei, Technical Lead

The frontend stack was built with Angular.

AI supported implementation, testing, and refinement. It did not replace engineering decisions, but it reduced repetitive work and shortened feedback cycles.

The impact of AI-first on the delivery timeline

AI acceleration was factored into the initial estimations. Even so, workflow optimization continued throughout execution.

In the end, we delivered approximately twice as fast as originally projected for the full lifecycle of all POCs.

This acceleration resulted from reduced manual coding effort, faster requirements clarification, automated test validation, and shorter feedback cycles.

Beyond delivery speed, the project resulted in a reusable technical template for AI-driven features. The architecture, orchestration patterns, monitoring approach, and feedback integration can now be reused in similar contexts and extended to new use cases.

This reduced future implementation risk and shortened the time required to move from idea to production-ready prototype.

The outcome was a validated and repeatable implementation model for AI-driven operational workflows in enterprise environments.