ClaimCall

• 

  ClaimCall — your AI agent that calls airlines so you don’t have to.

Inspiration

ClaimCall started with a real travel nightmare.

I was travelling from Dublin to Bangalore via Paris on Air France. A delay on the first leg caused me to miss my connection in Paris. What followed was an eight-hour wait, disruption to the journey, and then a long process trying to understand what I was entitled to and recover compensation.

The flight disruption itself lasted hours. Resolving everything around it took much longer.

I had to follow up repeatedly, navigate airline processes, gather information, make my case, and eventually escalate the matter with references to my passenger rights and possible legal action. After persistent follow-ups, I eventually recovered roughly 50% of the ticket value.

That experience originally inspired me to build C2C — Cancellation to Compensation Agent, an open-source agent exploring how AI could help passengers move from a flight cancellation or disruption toward an actionable compensation claim.

Building C2C exposed another important problem.

Even if an AI system understands passenger rights, reads documents, tracks a case, and recommends the next action, there is still a major gap:

Someone often has to pick up the phone.

Airlines, hotels, insurers, travel agencies, and other service providers still resolve many exceptional cases through phone conversations. Travellers end up waiting on hold, explaining the same situation repeatedly, asking the right questions, writing down promises, and following up again when those promises aren't fulfilled.

That led to the next question:

What if the agent could make that call for you?

That's where ClaimCall began.

ClaimCall extends the idea behind C2C into real-world phone execution: giving an agent the ability to identify when a call is necessary, define what needs to be accomplished, obtain human approval, make the call through CALL-E, and turn the conversation back into structured evidence and next actions.

---

What it does

ClaimCall is an AI agent that calls airlines so you don't have to.

A traveller provides the details of a disruption: their journey, booking reference, what happened, and the outcome they need.

ClaimCall turns that information into a structured resolution plan.

Instead of immediately making a call, the agent explains:

• why phone contact is necessary
• what information is missing
• what it intends to ask
• what it is allowed to do
• what it is not allowed to do

The traveller then reviews the plan and explicitly approves the call.

ClaimCall uses CALL-E to place the phone call and pursue clearly defined objectives such as:

• confirming why a flight was cancelled
• finding an available replacement itinerary
• asking whether accommodation is authorised
• asking about meal assistance
• requesting written confirmation
• identifying what the airline has committed to doing next

CALL-E turns the phone interaction into structured results that ClaimCall attaches to the disruption case.

Instead of the traveller finishing a call with scattered notes and another list of things to remember, ClaimCall produces a clear outcome:

What was confirmed?

What did the company promise?

What evidence do we now have?

What should happen next?

A phone conversation becomes structured, actionable case data.

---

How we built it

ClaimCall is designed as a focused agentic workflow rather than a general-purpose AI calling application.

The core flow is:

Travel disruption
        ↓
ClaimCall analyses the case
        ↓
Identifies missing information
        ↓
Generates a constrained call objective
        ↓
Human reviews and approves
        ↓
CALL-E executes the phone call
        ↓
Structured call result
        ↓
Commitments and evidence extracted
        ↓
Case state updated
        ↓
Recommended next action

The application uses a FastAPI/Python backend to manage disruption cases, generate call objectives, enforce agent boundaries, and integrate with CALL-E.

The frontend is built with Next.js and TypeScript, providing a case-oriented interface where the traveller can understand the reasoning behind the agent's actions rather than interacting with an opaque phone bot.

CALL-E is part of the runtime execution path. ClaimCall sends a specific phone task to CALL-E together with a structured result schema and processes the resulting call outcome back into the case.

We also designed ClaimCall with two execution paths:

Demo Mode allows the complete workflow to be demonstrated using clearly labelled synthetic results.

Live Mode uses CALL-E to initiate an actual outbound call after explicit human approval.

This separation allowed us to develop and test the case-management experience without pretending that simulated calls were real CALL-E executions.

---

Challenges we ran into

Turning an open-ended conversation into a bounded agent task

"Call the airline and fix my flight" sounds simple to a human, but it is dangerously ambiguous for an autonomous system.

What is it allowed to change? Can it accept a more expensive flight? Can it cancel another booking? Can it provide payment information?

We therefore had to convert a broad user goal into a constrained call contract containing explicit objectives and boundaries.

Knowing when autonomy should stop

We didn't want ClaimCall to become an agent that blindly makes consequential decisions.

The agent can analyse the case and recommend a phone call autonomously, but initiating an external call requires explicit human approval.

We also restrict the agent from making purchases, providing payment information, accepting new financial commitments, or modifying unrelated travel arrangements.

Converting conversations into useful outcomes

A transcript alone isn't a resolution.

The useful information is hidden inside it: what was confirmed, what changed, what was promised, what remains unresolved, and whether another action is required.

Using CALL-E's structured call results allowed us to model phone calls as state transitions in a larger agent workflow rather than treating the phone call as the final product.

Building for failure

Real phone calls don't behave like deterministic API requests.

People don't answer. Calls fail. Representatives may not resolve the issue. Information may be incomplete.

ClaimCall therefore treats unresolved and partially resolved as first-class outcomes instead of assuming every call succeeds.

---

Accomplishments that we're proud of

The biggest accomplishment is that the phone call isn't a gimmick added to an AI application — it closes a genuine gap in an existing agentic workflow.

ClaimCall combines:

• autonomous case analysis
• explainable decision-making
• human approval
• real-world phone execution through CALL-E
• structured outcomes
• evidence and commitments
• follow-up recommendations

We're particularly proud of the before-and-after case state.

Before the call, ClaimCall can show exactly what information is missing. After the call, it can show what changed because of the conversation.

That makes the agent's impact understandable and auditable.

We're also proud that ClaimCall grew from a problem experienced personally rather than starting with the question, "What can we build with an AI phone API?"

We started with:

"Why is resolving a disrupted journey still this painful?"

The phone agent emerged as part of the answer.

---

What we learned

The biggest lesson was that giving AI agents access to the telephone network changes what an agent can actually accomplish.

Most AI agents operate inside digital systems: APIs, databases, browsers, email, and messaging platforms.

But a huge amount of real-world business still happens through phone calls.

Adding voice execution means an agent can cross the boundary between a digital workflow and organisations whose processes still depend on human conversations.

We also learned that autonomy becomes more useful when it is bounded and explainable.

The interesting question isn't simply:

Can an AI agent make this phone call?

A better question is:

Can the system explain why the call is necessary, define exactly what the agent may accomplish, obtain human approval, execute the conversation, and turn the result into evidence that another system can act upon?

That is the model we explored with ClaimCall.

---

What's next for ClaimCall

Flight disruption is only the starting point.

The immediate next step is deeper integration between ClaimCall and C2C — Cancellation to Compensation Agent.

The two agents solve different parts of the same problem:

C2C
Understand disruption
        ↓
Determine passenger rights
        ↓
Organise evidence
        ↓
Determine required action
        ↓
CLAIMCALL
        ↓
Execute phone interaction
        ↓
Capture commitments + evidence
        ↓
C2C
        ↓
Continue claim / escalation

Beyond aviation, the same architecture could support phone-based resolution workflows across:

Travel: baggage claims, hotel disputes and travel insurance.

Insurance: claim-status calls, document follow-ups and coverage clarification.

Healthcare administration: appointment coordination and administrative follow-ups.

Utilities and services: billing disputes, service interruptions and account-resolution workflows.

The longer-term vision is therefore larger than an airline calling bot.

C2C provides the reasoning and claim workflow. ClaimCall provides the real-world phone execution layer.

Together, they point toward an agent that doesn't merely tell someone what they should do next.

It can help carry the resolution through to completion.

Built With

• agentic-ai
• ai-agents
• automation
• call-e
• conversational-ai
• fastapi
• human-in-the-loop
• llm
• next.js
• python
• rest-api
• structured-outputs
• traveltech
• typescript
• voice-ai