How ClearPath Logistics shipped an AI support agent that auto-resolves 73% of tickets in 90 days

The brief

ClearPath Logistics is a US-based logistics SaaS serving 200+ mid-market shippers. By Q4 2025 they were drowning in tier-1 customer-support tickets — order status checks, ETA queries, driver re-routes, BOL retrievals. Two full-time support reps were spending 70% of their week on the same 12 question patterns.

They had already burned $60,000 with two prior agencies trying to ship an AI support assistant. The first delivered a glorified FAQ chatbot that resolved 8% of tickets. The second went dark after the deposit cleared.

Then they called us.

The constraint

ClearPath had a hard constraint: the agent had to work with their real order data, in real time, without sending PII to a third-party. The cheap-and-cheerful path (drop a knowledge base into an Intercom AI chatbot) was off the table. They needed a custom AI agent that could:

• Look up live order data from their PostgreSQL warehouse via their internal API
• Read shipping-carrier APIs (FedEx, UPS, DHL) in real time
• Issue refunds < $200 autonomously, with audit logs
• Hand off to a human with full context when stumped
• Deploy entirely inside ClearPath's own AWS account — zero data egress

The approach

We used our standard 7-step agent framework, with three deviations specific to ClearPath's scale.

1. Eval set BEFORE architecture

Week 1 we shadowed their support reps and extracted 247 anonymized real tickets. From those, we built an evaluation set of 120 conversations with the "correct" answer for each — including the right tool calls. Every prompt change had to beat the previous version on this set or it didn't ship.

2. Hybrid model routing

Tier-1 intent classification ran on Claude Haiku ($0.001/turn). Complex multi-step reasoning ran on GPT-4o ($0.04/turn). This single decision cut their projected LLM bill by 71%.

3. Hard guardrails on actions

Refunds capped at $200 per call, $1,000 per customer per day, with full audit log to a protected Slack channel. Carrier API calls rate-limited. SQL queries scoped to read-only, validated against a strict allowlist. No prompt injection could expand the agent's blast radius.

The architecture

The system, in one diagram:

User on Intercom widget
        │
        ▼
   Intent Classifier (Claude Haiku)
        │
        ├──── Simple Q → KB lookup → respond
        │
        └──── Complex / action → LangGraph agent (GPT-4o)
                                       │
                                       ├── Tool: orders_lookup(order_id)  → ClearPath API
                                       ├── Tool: carrier_status(tracking)  → FedEx/UPS/DHL
                                       ├── Tool: issue_refund(amount, reason)
                                       ├── Tool: handoff_to_human(context)
                                       └── Tool: file_ticket(priority, body)

The 11-week timeline

Total engagement: $24,000 fixed-price, 11 weeks from kickoff to production. Milestones:

• Week 1: Discovery, eval set built, fixed scope signed
• Weeks 2–4: Agent core, tools, RAG over their docs and 18 months of closed tickets
• Weeks 5–7: Carrier integrations, refund-tool guardrails, admin dashboard
• Weeks 8–10: Shadow mode — agent generates responses, humans approve. Agreement reached 91% by end of week 9
• Week 11: Full production launch with human-approval threshold dropping over 14 days

The results — 90 days post-launch

Numbers pulled from their actual ops dashboard:

• 73% of inbound tickets auto-resolved with no human touch
• Median response time: 12 seconds (down from 4 hours)
• Support headcount avoided: 1.5 FTE that would have been needed at current growth — translating to $180,000 annual savings
• NPS for AI-resolved interactions: 4.6 / 5 (vs 4.2 / 5 for human-resolved)
• Customer-facing incidents: zero in the first 90 days

We'd already burned $60k with two other agencies. Paisol shipped our AI customer-support agent in 11 weeks — flat fee, no surprises. We've grown headcount in sales instead of support.

— Sarah Mensah, Founder, ClearPath Logistics

The stack we shipped

• LLMs: Claude 3.5 Haiku (classification), GPT-4o (reasoning)
• Agent framework: LangGraph for orchestration, OpenAI function calling for tools
• RAG: pgvector on their existing Postgres (no new infra), Cohere embeddings, hybrid search
• Backend: Next.js 14 API routes, Node.js, deployed to ClearPath's AWS account
• Frontend (admin): Next.js 14 dashboard, Tailwind, shadcn/ui
• Observability: Langfuse for trace logging, custom Slack alerts on guardrail trips
• Deployment: ECS Fargate inside ClearPath's VPC, behind their existing ALB

What we'd do differently next time

Two things, in the spirit of full disclosure:

1. Ship the agent in shadow mode 2 weeks earlier. We spent weeks 8–10 in shadow mode; in retrospect, weeks 6–10 would have given us 2 more weeks of real-world data and smoother launch.
2. Build the eval dashboard for the client, not just us. The eval set was gold — but it lived in our private repo. We've since standardized on shipping the eval dashboard to clients on every engagement.

Numbers for the math nerds

The annual return on the build:

• Build: $24,000 (one-time, fixed)
• Annual LLM + observability + vector DB: $7,200 ($600/mo)
• Maintenance retainer (first 6 months): $21,000
• Year-1 total cost: ~$52,200
• Year-1 hard savings: $180,000
• Net Year-1 ROI: 244%
• Payback period: 3.5 months

Plug your own ticket volume into our AI Agent ROI Calculator for an instant equivalent estimate.

Want to ship something like this?

Book a free 30-minute strategy call. We'll look at your ticket data, your stack, your constraints — and tell you honestly what shipping an agent like ClearPath's would cost and how long it would take. Or read the pillar guide: What is an AI agent?