InsurAsync

Inspiration

So, this whole idea popped into my head because of something that happened to a buddy of mine. His younger brother accidentally bumped his car into a university bus. It wasn't a huge crash or anything, but the car needed fixing, and it took ages, like weeks, for the insurance stuff to finally get sorted out.

Now, this brother relied on that car to get to university every single day. For those weeks he couldn't drive, someone else had to give him a ride instead. And this happened every day, for a situation that honestly felt like it should have been wrapped up in a few days, not weeks.

When I saw the WebMCP challenge, that whole experience just flashed back to me. The real bottleneck wasn't the accident itself, but the fact that everyone involved was stuck passing information back and forth manually. The insurance company needed paperwork from the car owner, and the repair shop needed approval from the insurance company. Nobody had a quick, direct way to just communicate with each other. That's when I realized this is precisely the sort of issue WebMCP is designed to tackle: instead of a person acting as the manual link between three different systems, let each party have actual tools that an agent can directly access.

That's how InsurAsync was born.

What it does

InsurAsync is a demo insurance claim platform with three separate parties — a policyholder, an insurer, and a repair shop each with their own page and their own WebMCP tools:

• The policyholder's agent can file a structured incident report and upload documents.
• The insurer's agent checks real coverage terms, requests exactly the documents needed, and validates repair estimates against real policy limits.
• The repair shop's agent proposes and revises estimates based on real parts and labor pricing.

A shared live log shows every step as it happens, so you can watch the whole negotiation unfold in real time. And importantly, the very last step, actually confirming the settlement, is something only a human can do. The agents can negotiate everything up to that point, but they can never be the ones to finalize it.

How we built it

I built InsurAsync with Next.js, using WebMCP's document.modelContext.registerTool() on each of the three party pages to expose real, callable tools. Every tool is backed by an actual API route with real validation logic, real coverage limits, real document requirements, real repair pricing, so an agent calling these tools gets back genuine data, not guesses.

For persistence, I initially tried a simple file-based store, but once I deployed to Vercel I learned that serverless functions don't reliably share a filesystem between requests. I ended up switching to a real Redis database (hosted on Vercel) so claim data actually survives across requests and cold starts, something I tested thoroughly before trusting it for the live demo.

To actually prove the WebMCP integration worked, I tested it with a real agent using ChatGPT's in-app browser, prompting it to file a claim, check coverage, upload documents, propose an estimate, and validate it all through the real tools, live, on the deployed site.

Challenges we ran into

• Getting real persistence working. My first attempts (in-memory storage, then file-based storage) worked locally but silently failed once deployed, because serverless environments don't behave like a normal always-on server. Moving to Redis fixed this properly.
• Finding the right way to test WebMCP tools with a real agent. Chrome's WebMCP testing flag turned out to be inconsistent in exposing document.modelContext reliably in my setup, and regular ChatGPT browsing only reads page text, it doesn't call in-page tools. ChatGPT's dedicated in-app browser was the one that actually worked, and once I found it, the whole negotiation flow worked end to end on the first real try.
• A very small but very stubborn bug: I once had the code from my "revise estimate" tool accidentally pasted into my "propose estimate" file, which silently broke the flow with a confusing error message until I traced it back to a simple copy-paste mix-up.

Accomplishments that we're proud of

Getting the full three-party negotiation to actually work end-to-end, live, with a real agent not just simulated with manual API calls is the accomplishment I'm most proud of. Watching ChatGPT file a claim, get asked for documents, upload them, get a repair estimate priced and validated against real policy limits, all without me typing anything into a form, was the moment the idea stopped being a concept and became a real working thing.

I'm also proud of getting the human-in-the-loop boundary right: the agents can do all the negotiating, but only a real person can click Confirm Settlement. That felt like an important line to draw, not just a technical detail.

What we learned

The biggest thing I learned is that WebMCP tools are only as trustworthy as the real logic behind them. It would have been easy to build tools that just returned made-up numbers, but the moment I wired every tool to real stored data actual coverage limits, actual document requirements, actual repair pricing, the whole demo became something I could actually trust watching an agent operate. That distinction, between an agent guessing and an agent calling a tool with real validation behind it, is the whole point of WebMCP, and building this made that click for me in a way just reading about it hadn't.

What's next for InsurAsync

• Real authentication, so each policyholder, insurer, and repair shop sees only their own claims instead of the most recent one
• Real document uploads instead of file-reference placeholders
• Support for more incident types and more nuanced coverage rules
• A dispute/counter-offer flow, so an insurer and repair shop can go back and forth on an estimate more than once before it's approved
• Exploring what this pattern looks like for other multi-party processes with the same "everyone relays information by hand" problem — warranty claims, permit approvals, or multi-vendor project sign-offs

Built With

• css
• javascript
• nextjs
• node.js
• react
• redis
• vercel
• webmcp