Skip to content
All projects

2025 · Case study

Autodesk AI Support & Multi-Agent Orchestration System

Autonomous customer support that knows when to stop guessing.

An enterprise-grade multi-agent customer support and ticketing system for Autodesk-style workflows. A LangGraph StateGraph router performs zero-shot intent classification, sentiment and urgency triage, then hands off to specialised domain agents — escalating to humans over Redis Pub/Sub the moment confidence drops below 0.70.

  • Python
  • FastAPI
  • LangGraph
  • Streamlit
  • Multi-Agent Systems
  • PostgreSQL
  • Redis
  • JWT Auth
  • Docker
  • NLP
Live demo Source code

01

The problem

Customer support queues drown in repetitive, high-volume tickets: order status, licence provisioning, billing questions, refund eligibility. Each one is individually trivial and collectively expensive.

The naive fix — a single LLM answering everything — fails in exactly the place it matters most. It answers confidently when it shouldn't, has no notion of urgency, and gives human agents nothing useful when it finally gives up.

The goal here was an autonomous support layer that resolves what it genuinely can, measures how sure it is, and escalates the rest with enough context that a human doesn't have to start over.

02

Architecture

The system is modelled as a LangGraph StateGraph rather than a prompt chain. A RouterAgent performs zero-shot intent classification into ORDER_STATUS, REFUND_REQUEST, PAYMENT_ISSUE, TECHNICAL_SUPPORT or GENERAL_INQUIRY, each with an explicit confidence score, alongside sentiment and urgency analysis.

Conditional edges then route to a specialised domain sub-agent: OrderAgent for tracking, licence provisioning and delivery; PaymentAgent for invoices, gateways and billing updates; ReturnRefundAgent for software return eligibility and refund processing; and a KBPolicyRetriever that queries a vector policy store for general questions.

The escalation engine is the deliberate part of the design. When classifier confidence falls below 0.70, or the customer reads as frustrated / the ticket scores PRIORITY: HIGH or CRITICAL, a context-rich payload is broadcast over Redis Pub/Sub to a human support queue instead of being answered anyway.

A Streamlit dashboard sits in front of a FastAPI service, with full JWT session management — access and refresh tokens, plus browser query-parameter restoration so a page refresh doesn't dump the agent out of session.

LangGraph StateGraph orchestration
Interface
  • Streamlit Support Dashboard
API
  • FastAPI Backend (JWT / OAuth2)
Orchestrator
  • LangGraph Router Agent — intent + urgency
Domain sub-agents
  • OrderAgent
  • PaymentAgent
  • ReturnRefundAgent
  • KB Policy Retriever
Fallback
  • Escalation Engine — Redis Pub/Sub → human queue

Sentiment + confidence scoring runs across every hop. Confidence ≥ 0.70 resolves autonomously; frustration or < 0.70 escalates with full context.

03

Tech stack & why

  • Orchestration

    LangGraph + LangChain

    Stateful graph with conditional edges — routing and escalation are explicit topology, not prompt-engineered hope.

  • Backend

    FastAPI + Pydantic v2

    Async API service with strict schema validation at the boundary.

  • LLM

    Google Gemini (gemini-3.1-flash-lite)

    Fast, cheap classification and generation for a high-volume triage workload.

  • Data

    PostgreSQL (psycopg3) / SQLite

    Relational storage for users, tickets and message history.

  • Events

    Redis 7 Pub/Sub

    Decouples escalation broadcasting from request handling — human queues subscribe independently.

  • Security

    PyJWT, Bcrypt, OAuth2

    Password hashing plus role-based access control across the dashboard and API.

  • Deployment

    Docker Compose

    PostgreSQL, Redis, FastAPI, Streamlit and pgAdmin come up as one reproducible stack.

04

Challenges & solutions

  • 1

    Knowing when the agent is wrong

    Confidence scoring is wired into the routing decision itself. Below 0.70 the graph does not attempt a resolution — it takes the escalation edge. That single threshold is what makes the system safe to point at real customers.

  • 2

    Session survival in Streamlit

    Streamlit's rerun model repeatedly loses in-memory state. JWT access and refresh tokens are restored from browser query parameters so an authenticated session survives page refreshes.

  • 3

    Escalations that are actually useful

    The escalation payload carries intent, sentiment, urgency and conversation context, so the human agent inherits the reasoning rather than a bare transcript.

  • 4

    Reproducible multi-service local runs

    Five interdependent services made 'works on my machine' a real risk. A single docker-compose definition builds and launches the whole stack, with a Python-only path documented as a fallback.

05

What I'd build next

  • Add an offline evaluation suite that scores routing accuracy and escalation precision against a labelled ticket set, so threshold changes are measured rather than guessed.
  • Introduce per-tenant knowledge bases so the policy retriever can serve multiple product lines from the same deployment.
  • Surface live agent-performance telemetry — resolution rate, escalation rate and latency per intent — inside the dashboard.

Next case study

VideoMind

Read it