Trustlane

Trustlane is an AI warranty coordinator for Australian EV dealerships that automates the end-to-end warranty claim process, from technician call to compliant submission.

Comment

Inspiration

The idea started with Nathan watching an ABC News story about EV warranty delays in Australia. One example immediately stood out: for one EV brand, a repair over $5,000 could be sent to China for an approval process that took up to eight weeks.

Eight weeks.

That was the moment Nathan brought the problem to the team and said, “Omg! We found a really good idea for the hackathon.”

From there, we started digging.

The deeper we looked, the more we realised the delay was not just one bad case. An independent review commissioned by the Australian Automotive Dealer Association described dealers dealing with long approval chains, different manufacturer requirements, and one dealer spending around six hours just preparing a single warranty claim.

Then we started looking at the customer side. We found owners waiting months for warranty decisions, dealers stuck between the customer and the manufacturer, and technicians who could identify a fault quickly but still could not move the repair forward without the right evidence and approval.

That was when this stopped being an interesting news story and became something we genuinely wanted to build.

The problem was not simply that warranty claims were slow. It was that the information needed to move them forward was scattered between the dealer, the technician, the OEM and the customer. A missing measurement or unsupported finding could create another request for information, another phone call, another review cycle and another week of waiting.

So we asked a simple question:

What if an AI system could sit in the middle, understand what evidence was missing, help collect it while the vehicle was still there, and keep the claim moving without taking control away from the humans responsible for the decision?

That became Trustlane.

Part of why the idea came together so quickly was that our team looked at the same problem from different angles. Nathan found the problem through the ABC story, others dug into the legal and dealer reports, and others started translating those findings into workflows, schemas and agent behaviour. The product really clicked when those perspectives came together.

What it does

Trustlane is an AI warranty coordinator that sits between the dealer and the OEM for EV warranty claims.

  • It turns warranty requirements into something the system can actually reason over. Instead of relying on tribal knowledge, Trustlane represents configured OEM evidence requirements as structured rules and checks every case against them. Each requirement stays visibly SATISFIED, MISSING, CONFLICT, UNSUPPORTED, UNCERTAIN, or NOT_APPLICABLE, so the dealer can see exactly what is blocking the claim and why.
  • The Dealer Agent tries to catch problems before the claim leaves the workshop. It searches the evidence already available, runs compliance checks, explains gaps and conflicts, and tells the dealer what still needs attention. Regulatory context and reimbursement can be investigated when relevant, but they remain separate from the OEM's evidence requirements.
  • When the missing evidence is still with the vehicle, Trustlane can go and get it. If the Dealer Agent determines that an unresolved requirement needs a live physical observation, it prepares a bounded technician call for the dealer to approve. ElevenLabs then speaks with the technician while they are at the vehicle, and the transcript becomes an auditable evidence source. Trustlane extracts proposed facts from that conversation, but a human must verify or correct them before they can affect compliance. The technician effectively becomes the AI's eyes and hands at the vehicle.
  • The OEM gets its own independent Agent. Once the human dealer submits the claim, the OEM Agent reviews the submitted evidence snapshot rather than simply trusting the dealer's summary. It can challenge unsupported claims and recommend either APPROVE or REQUEST_MORE_INFORMATION, including a specific evidence request when something is still unresolved. The human OEM reviewer makes the final decision.
  • AI does the reasoning, not the authorising. Trustlane can search, explain, recommend, draft and coordinate evidence collection, but it cannot autonomously submit a claim or approve one. Deterministic tools calculate compliance, the agents reason over those results, and humans remain in control of consequential actions.

We designed Trustlane around the part of the process that creates the most avoidable back-and-forth: finding, checking and recovering missing evidence. Australian dealer reporting includes one dealer describing six hours of work to prepare a single warranty claim, while broader warranty resolution can stretch to six to eight weeks.

Based on the workflow we built, we model a comparable Trustlane-assisted case at roughly 20 minutes of active dealer handling instead of six hours. That is an illustrative prototype estimate, not a measured production result, and validating it with a real dealer pilot is one of our next goals.

How we built it

The first problem was data. Real OEM warranty procedures are not public, and there is no open dataset of dealer warranty claims we could simply train or test against. The parts that matter most, evidence requirements, submission rules, escalation thresholds and reimbursement rules, normally live inside manufacturer and dealer systems. So instead of pretending we had access to something we did not, we separated what was publicly verifiable from what had to be modelled for the prototype, then built transparent synthetic warranty cases around that.

From there, we designed Trustlane around two AI agents only: a Dealer Agent and an OEM Agent. We used the OpenAI Agents SDK for the reasoning layer, with Convex holding the case state, evidence, permissions and workflow. The Dealer Agent helps prepare a claim before submission, while the OEM Agent independently reviews the submitted snapshot. We deliberately kept those roles separate because we did not want one model acting as both the person asking for approval and the person granting it.

The most important architectural decision was that the LLM does not get to invent the business rules. Compliance is handled by deterministic tools. Each requirement comes back as one of six states: SATISFIED, MISSING, CONFLICT, UNSUPPORTED, UNCERTAIN, or NOT_APPLICABLE. The agents can search evidence, explain why something is blocking the claim, retrieve regulatory context, and check reimbursement logic, but they have to reason from the outputs of those tools rather than making up their own result. Regulatory guidance is also kept separate from OEM policy, so finding something relevant under Australian Consumer Law does not silently erase an OEM evidence requirement.

We also built evidence provenance into the workflow from the start. Documents and extracted facts stay linked back to their source, and facts can be proposed, verified, corrected or rejected by a human. The Dealer Agent cannot submit a claim by itself, and the OEM Agent cannot approve one by itself. The AI can recommend and draft, but consequential actions stay behind human approval.

The ElevenLabs integration came from asking a different question: what happens when the missing evidence is not in a document at all, but is physically sitting with the technician and the vehicle? We added a Dealer-only technician-call capability. If the Dealer Agent searches the existing evidence and determines that a live observation is genuinely needed, it can prepare a bounded call for approval. Once the dealer approves it, ElevenLabs handles the technician conversation. The speech is transcribed, Trustlane extracts proposed evidence from that transcript, a human verifies it, and the compliance check runs again. That lets the technician effectively become the AI's eyes and hands at the vehicle without giving the voice system authority to make warranty decisions.

We spent almost as much time testing the agents as building them. We extended the evaluation harness to cover 33 behavioural scenarios, including missing evidence, conflicting measurements, citation grounding, reimbursement questions, regulatory issues, adversarial instructions, Dealer/OEM role boundaries and technician-call behaviour. Those tests caught real failures, including an agent becoming ready while a requirement was still blocking submission, reimbursement reasoning leaking into approval recommendations, and regulatory context being treated as if it could override an OEM requirement. Every demo-blocking failure became a regression test.

By the end, the final workflow completed three consecutive end-to-end reference runs, each passing 8/8 agent turns and 9/9 technician-call checks. We also built the full product around it: Dealer, OEM and Admin role-based access, evidence views, agent chat, technician-call flow, claim state tracking, and separate Dealer and OEM workspaces. The result is not just a chatbot sitting next to a warranty form. It is a working workflow where AI reasons, deterministic tools calculate, and humans remain in control.

Challenges we ran into

The first challenge was simply not having the data we wished existed. Real OEM warranty procedures, dealer claim histories and internal evidence rules are commercially sensitive, so there was no clean public dataset we could build against. We had to be very deliberate about separating what we could verify publicly from what we were modelling for the prototype.

Getting real system access was another wall. Titan's developer environment requires commercial access before we can see the full workshop, repair-order and evidence data we would want in production. Rather than fake that integration, we built the adapter boundary and used uploaded evidence for the working prototype so real dealer data can slot in later.

But the hardest challenge ended up being the agents themselves.

A model sounding convincing was not enough. During evaluation we caught cases where the Dealer Agent could say a claim was ready while evidence was still blocking submission, reimbursement reasoning leaked into approval recommendations, regulatory context was treated as if it could override an OEM requirement, and long citation IDs were copied incorrectly.

The ElevenLabs workflow created another class of problems. The Dealer Agent had to search existing evidence before deciding a technician call was necessary, the questions had to be tied to a real unresolved requirement, and a technician's answer could not silently become verified evidence just because the AI heard it.

So we built behavioural evaluations around those failure modes and treated every serious failure as something to reproduce, fix and keep as a regression test.

The other challenge was discipline around numbers. It is incredibly tempting at a hackathon to take the most exciting estimate and present it like a measured result. We made ourselves keep three things separate: what came from an external source, what came from our own test runs, and what is still a modelled assumption that needs a real pilot.

Accomplishments that we're proud of

We are proud that Trustlane became much more than the document assistant we originally imagined.

By the end of the build, we had a complete Dealer-to-OEM workflow with separate Dealer, OEM and Admin roles, evidence provenance, deterministic compliance checking, an OpenAI Agents SDK reasoning layer, human-controlled submission and approval, and a working ElevenLabs technician evidence loop.

We also spent almost as much effort challenging the agents as building them. Our evaluation harness grew to 33 behavioural scenarios covering evidence gaps, conflicting measurements, citation grounding, regulatory reasoning, reimbursement, adversarial instructions, Dealer/OEM role boundaries and technician-call behaviour.

After the failures we found were fixed and turned into regression tests, the final workflow completed three consecutive end-to-end reference runs, with each run passing 8/8 agent turns and 9/9 technician-call checks.

One of the things we are most proud of is that the voice feature is not just there because voice AI looks cool in a demo. It solves a specific physical-world problem: sometimes the missing evidence only exists with the technician standing next to the vehicle. Trustlane can detect that gap, prepare the right questions, get human approval, use ElevenLabs to collect the observation, turn the transcript into proposed evidence, and feed it back into the same compliance workflow.

On the business side, one Australian dealer reported spending around six hours preparing a warranty claim. Based on our prototype workflow, we model the equivalent active dealer involvement at roughly 20 minutes. That number is intentionally labelled as an estimate rather than a customer result, because the next step is to validate it with a real dealership.

Most importantly, we did not have to choose between making the demo impressive and making the architecture defensible. The final system follows one principle throughout:

AI reasons. Deterministic tools calculate. Humans decide.

What we learned

The biggest thing we learned is that the real friction in warranty claims is not usually the headline warranty coverage every manufacturer publishes. It is the operational layer underneath: what evidence is required, what format it needs to be in, who has the missing information, and what happens when the first submission is not enough.

We also learned that agentic AI works much better when the model is not responsible for everything. Some parts of the workflow should stay deterministic. Compliance states, reimbursement logic, and evidence requirements should not change just because the model phrases something differently. The LLM is much more useful when it reasons over trusted outputs, explains what is happening, and decides what tool or next step is appropriate.

Another important lesson was that regulatory context and OEM policy have to stay separate. Australian Consumer Law can matter to the person reviewing a case, but that does not mean the AI should silently override an OEM evidence requirement. Keeping those two concepts separate made the system much easier to trust.

The ElevenLabs integration also changed how we thought about voice. Voice is most useful when the missing information exists somewhere outside the software. In our case, that information can be with the technician standing next to the vehicle. That turned voice from a nice demo feature into a real operational capability.

And finally, we learned how important evaluation is for agents. Several behaviours looked completely reasonable until we tested them with adversarial scenarios. Once we started measuring tool choice, citations, recommendation boundaries and role behaviour, we found issues we would never have caught by just clicking through the happy path. By the end, every demo-blocking failure we found became a regression test.

What's next for Trustlane

  • Run a real dealer pilot. Our first goal is to validate the modelled six hours to roughly 20 minutes of active dealer handling against real warranty cases and replace our assumptions with measured results.
  • Connect to real dealer systems. We want production access to Titan workshop, repair-order and evidence data so Trustlane can fit into the systems dealers already use rather than relying primarily on uploaded documents.
  • Work with a real OEM. The hackathon uses transparent modelled OEM procedures because genuine internal warranty rulebooks are commercially sensitive. A pilot with an OEM would let us configure and validate Trustlane against real requirements.
  • Take the technician voice workflow into production. The next step for the ElevenLabs integration is real technician calling, production consent and privacy controls, failure handling, scheduling and multilingual support where there is a genuine operational need.
  • Strengthen auditability. We want deeper version history for claims that change after review, clearer handling of disputed repairs, and stronger escalation when an OEM requirement appears to conflict with regulatory guidance.
  • Keep expanding the evaluation suite. The current behavioural tests already caught issues that a normal unit-test suite would never see. As real cases arrive, we want those cases to become new regression scenarios so Trustlane gets more reliable with every pilot.

Built With

  • ai-elements
  • better-auth
  • convex
  • convex-test
  • elevenlabs
  • lucide-react
  • next.js-16
  • openai-agents-sdk
  • react-19.2
  • react-resizable-panels-v4
  • recharts-3
  • shadcn/ui-on-harbor-design-tokens
  • tailwind-css-v4
  • typescript
  • vitest
  • web-push-with-@convex-dev/workpool
Share this project:

Updates

Submission history