ProveIt is a consumer advocacy company supporting Romanian-speaking customers across the UK. Their mission is simple and serious. Help people reclaim money lost through car finance mis-selling, without exploiting them in the process.
But delivering that mission came with a growing operational cost.
Every customer case triggered long email chains between three parties: the customer, the finance provider, and ProveIt’s team. Each incoming message had to be opened, read carefully, understood in context, mapped to the correct stage of the claims process, and answered using the right legal template. Often in two languages. Often with incomplete information. Always under time pressure.
At scale, this became a bottleneck.
Thousands of emails flowed through the system, each demanding human attention. Not because the work was complex in principle, but because the variation was relentless. Different finance providers. Different wording. Different customer situations. The same core decisions, repeated again and again by skilled people.
This was not just an admin problem. It was an operational one.
ProveIt faced a real tension between growth and trust. Scaling the service meant handling more cases, faster, at a lower cost per claim. But cutting corners risked undermining the care, accuracy, and reassurance that customers relied on, especially when navigating legal and financial systems in a second language.
The challenge was clear. How do you reduce manual effort and operating cost without turning a human service into a cold, automated one? How do you scale impact without eroding trust?
That question set the direction for everything that followed.
When ProveIt joined the Agentic Incubator, we started with a deceptively simple question. What if the inbox itself could think?
Not a rules engine. Not keyword matching. An agent that could read an email in context, understand what stage a case had reached, identify the underlying intent, select the correct next step from over fifty approved templates, and draft a response ready for human review.
The goal was not to replace people. It was to remove the repetitive judgement calls that were consuming their time.
This was a deliberate shift away from surface automation. We were not interested in bolting a chatbot onto the front of an already fragile process. We wanted to change how work flowed through the system. Decisions first. Messages second. Humans overseeing outcomes, not wrestling with inboxes.
In practical terms, this meant treating each email as a unit of work, not just text. The agent needed to understand conversation history, recognise patterns across finance providers, handle Romanian and English interchangeably, and stay grounded in ProveIt’s proven legal templates. Every action had to be traceable. Every output had to be predictable.
This was not experimentation for its own sake. It was a redefinition of the operating model.
By shifting intent recognition and next-step selection into an agent, ProveIt could move from manual handling to assisted execution. People stayed in control, but the system absorbed the cognitive load. Work that once required careful human triage became fast, consistent, and scalable.
This is what agentic software looks like when it is designed around real work, not novelty.
From the outset, we knew this could not be a single model doing everything. The risk was too high and the trust requirement too strong. Instead, we engineered a hybrid architecture designed for real operational work.
At the top sat a non-deterministic layer, powered by GPT. Its role was interpretation. Reading messy, real-world emails. Handling Romanian and English interchangeably. Understanding intent, tone, and context across long, fragmented email threads. This was where human-like judgement mattered.
Beneath that sat a deterministic layer responsible for control. Once intent was understood, the system did not generate free-form responses. It selected from a curated library of approved legal templates and injected them exactly as defined. No creative drift. No wording surprises. No risk of saying the wrong thing.
This separation was deliberate.
Interpretive intelligence without guardrails creates risk. Guardrails without intelligence create brittleness. Together, they created something far more useful. An agent that could think flexibly, but act precisely.
That combination became the heart of the ProveIt agent.
As we built and tested the system, patterns began to emerge. The same structure kept repeating. Sense the situation. Decide the next step. Execute within strict constraints. Capture feedback. Improve over time.
We realised we were not just solving one problem. We were uncovering repeatable agentic patterns that could be applied well beyond this use case. Anywhere work is driven by unstructured input, governed decisions, and high trust requirements, the same approach holds.
This was not about writing smarter code. It was about designing intelligent execution systems that businesses could rely on.
It did not take long for the conversation to change.
Once the first agent was working reliably, a new question emerged. What if this was not a single capability, but the start of a system? What if different agents could specialise, each owning a specific slice of the work?
One agent focused purely on template triage and selection. Another tracked timelines and case ageing, recognising when a response was overdue or when proactive follow-up was required. Another handled edge cases and escalations, flagging situations that fell outside the happy path and needed human judgement.
What began as one intelligent workflow started to look like a coordinated set of agents, each with a clear responsibility.
The architecture started to resemble microservices, but with a critical difference. These were not static components executing predefined logic. Each agent had intent, context, and the ability to adapt within its remit. They communicated through shared state rather than brittle integrations. Work flowed between them based on what the situation demanded, not what a diagram dictated months earlier.
This shift mattered.
Instead of scaling by adding more people or hard-coding more rules, ProveIt could scale by adding capability. New agents could be introduced without rewriting the whole system. Complexity was absorbed horizontally, not piled onto a single overworked component.
This is where agentic systems move from feature to foundation. Not a smarter inbox, but an intelligent execution layer that grows with the business.
👉 Find out more about Multi-Agent Systems in the Context of Agentic AI
The results were immediate and measurable.
Response times collapsed from days to under an hour, removing one of the biggest sources of customer anxiety. Case-handling capacity increased by more than 50 percent without adding headcount, fundamentally changing the cost to serve. The same team could now help far more people, faster, and with greater consistency.
Crucially, trust was never traded away. Every AI-generated draft still flows through human review. People remain accountable for what goes out the door, while the agent absorbs the heavy lifting that once slowed everything down.
Operationally, the system runs entirely inside ProveIt’s own Azure tenant. That means full governance, clear auditability, and a platform that can evolve safely as regulation, volumes, and services change.
This was not efficiency theatre. It was a genuine shift in how work gets done.
Adrian is clear about what mattered most. The hardest part was not the technology. It was starting.
Once the team committed to moving beyond theory and into production, everything else followed. The value came from putting agents into real workflows, learning fast, and refining in the open, not from waiting for perfect answers.
ProveIt’s journey shows what happens when organisations choose to lean in. No sandboxes. No hype-driven pilots. Just real agents, operating in live environments, taking on meaningful responsibility.
This is what agentic software looks like when it is treated as an operating model, not a novelty. And it is already transforming how serious work gets done today.
---
The full conversation with Adrain can be found here:
👉 The Next Thing Now Podcast: AI Agents in Financial Services