CasePilot

Most customer service issues take multiple calls. Case Pilot keeps your case moving—prepping calls, handling wait time, escalating to you when needed, and making every follow-up easier.

Comment

Inspiration

Customer service is broken—not because calls are hard, but because cases don’t persist.

Most real-world issues (flight refunds, insurance claims, billing disputes) take multiple calls. Every time, users:

  • re-explain everything
  • lose context and reference numbers
  • don’t know what to do next

We realized the problem isn’t “how to talk to customer service.”

It’s: how to move a case forward across multiple calls.

That insight led to CasePilot.

What it does

CasePilot is an AI case manager for customer service.

Instead of just making a phone call, it:

  • prepares the case before calling
  • handles IVR, waiting, and repetitive conversation
  • transfers to the user only when necessary
  • remembers everything and improves the next call

In short:

Vapi runs the call. CasePilot moves the case.

The key innovation is case continuity:

  • every call builds on the last
  • every failure becomes a learning signal
  • every next step is clearer than before

How we built it

We designed the system around the real lifecycle of a customer service case.

Core architecture:

  • SQLite → persistent source of truth (cases, calls, transcripts)
  • Redis → runtime memory (what the AI needs right now)
  • TinyFish → pre-call research (numbers, departments, requirements)
  • Vapi → phone execution (dialing, IVR, transfer, recording)

Flow:

  1. Create a case (not just “make a call”)
  2. Run pre-call research
  3. Collect only necessary user inputs
  4. Build a call plan
  5. Execute via Vapi
  6. Transfer to user when needed
  7. Persist outcomes and update memory

The critical design decision:

We separate “truth” from “inference memory.”

  • SQLite = everything that happened
  • Redis = what the AI should use right now

That’s what enables multi-call intelligence.

Challenges we ran into

1. Not overbuilding a phone bot It’s easy to just demo “AI talking on the phone.” That’s not the product. We had to force ourselves to build the case layer.

2. When to transfer to the user Too early → AI useless Too late → call fails

We had to define clear escalation rules:

  • identity verification
  • OTP / payment
  • explicit refusal from agent

3. Memory design (harder than expected) If you dump everything into the prompt, it breaks. If you store too little, the system isn’t useful.

We solved it with:

  • structured persistence (SQLite)
  • compressed runtime memory (Redis)

4. Pre-call intelligence quality If research is wrong, everything downstream fails. We had to ensure:

  • verification (Search + Fetch)
  • normalized outputs
  • human override when needed

Accomplishments that we're proud of

  • Built a full case lifecycle system, not just a call demo
  • Achieved true multi-call continuity (calls get smarter over time)
  • Designed a clean separation of system layers (SQLite / Redis / Vapi / TinyFish)
  • Implemented human-in-the-loop escalation in a reliable way

  • Created a demo where:

    • the system remembers previous failures
    • the next call is visibly better

The biggest win:

We didn’t just automate a call—we improved the outcome of the next one.

What we learned

  • Customer service is a stateful problem, not an interaction problem
  • “Fully autonomous AI” is less useful than well-timed human involvement

  • The real leverage is in:

    • preparation
    • memory
    • iteration

Also:

AI products feel 10x smarter when they remember.

What's next for CasePilot

Right now, we’ve proven the core loop.

Next steps:

1. Stronger pre-call intelligence

  • better routing (which number actually works)
  • better department targeting
  • smarter intake

2. Failure learning loop

  • aggregate patterns across cases
  • improve scripts and strategies automatically

3. Vertical expansion

  • travel → insurance → telecom → healthcare
  • focus on high-friction, multi-call workflows

4. B2B use cases

  • executive assistants
  • concierge services
  • claims teams

5. Productization

  • timeline UI for cases
  • automated follow-up scheduling
  • proactive “you should call now” recommendations

Long-term vision:

CasePilot becomes the system that owns your customer-service cases— not just the calls, but the outcomes.

Built With

Share this project:

Updates