-
-
The Hero Section: Gives the tagline and clear overview of the agent, with a breah/ no breach toggle enabling us to view both the scenarios.
-
The four agent pipeline, where each agent remains locked until the previous agent completes it's job.
-
The finance agent, the final agent gives us the clear credit value for our claim, with a generate claim button for more details
-
On clicking generate claim, we get the whole finance review with the most specific details & descriptions of our claim.
-
We also have a No breach scenario added, which serves as a proof that Vindex clearly goes through each contract before making claims.
Inspiration
Honestly, this came from something a lot smaller than enterprise contracts, that's freelancing. When you're managing multiple clients, tracking who paid what, when, and whether a deliverable actually got what was promised, you realize how easily things slip through. Nobody's sitting there cross-checking every invoice against every agreement; you just trust it works out, or you notice months later that it didn't. Then we looked at enterprise vendor contracts and realized the exact same thing happens at a much bigger scale. Companies sign SLAs with uptime guarantees and credit clauses, but almost nobody actually checks whether a vendor breached that promise, because doing it manually means reading a contract, digging through logs, and doing the math yourself, every single month. So the money owed just goes unclaimed. It's the same problem we'd seen up close, just with a lot more zeros attached. That's what we wanted to fix.
What it does
VINDEX turns a static vendor contract into a continuously enforced financial claim. It runs through four agents, each handling a distinct part of the job: Contract Agent : reads the vendor contract and extracts the actual SLA terms: uptime threshold, credit formula, contract value. Telemetry Agent : scans operational logs and detects any period where performance dropped below that threshold. Evidence Agent : cross-checks the contract terms against the telemetry findings and confirms whether it's a real, defensible breach. _Finance Agent _ : calculates the exact credit owed and compiles it into a claim-ready package. The output isn't just "a breach happened" , it's a specific dollar amount, backed by evidence, ready to submit. We also built in a no-breach scenario, so the tool only flags a claim when the evidence actually supports one, rather than always returning a positive result.
How we built it
We currently built VINDEX as an interactive prototype using v0, keeping the architecture deliberately lean. Breach detection and the final credit calculation are handled with straightforward deterministic logic, comparing telemetry data against contract thresholds rather than sending everything through an AI model. AI is reserved for the one place it's genuinely needed: reading and extracting structured terms from unstructured contract language. That split keeps the system cheap to run and, just as importantly, auditable. A financial tool shouldn't be a black box making money-owed decisions with no visible reasoning.
Challenges we ran into
Getting the visual design right took several iterations. We wanted VINDEX to feel like serious financial infrastructure, not a flashy AI dashboard, which meant a lot of back-and-forth on color and layout to land on something restrained and trustworthy rather than "AI-generated template" looking. We also had to be intentional about not overbuilding: it would have been easy to add real API integrations, authentication, and multi-vendor support, but we scoped hard to one clear, demonstrable case so the core agent logic stayed the focus.
Accomplishments that we're proud of
Getting all four agents to hand off structured output to each other in a way that's genuinely traceable. You can see exactly which contract clause, which telemetry window, and which calculation produced the final number. We're also proud of building in the no-breach case, which was important to us: it proves the system evaluates real evidence instead of being rigged to always find a violation.
What we learned
We learned a lot about frugal AI architecture, that not every step in a pipeline needs an LLM call, and that deterministic logic is often more defensible (and cheaper) than AI reasoning, especially for anything involving financial calculations. We also learned how much of a product's credibility comes from restraint in design, not just functionality, small details like color and copy changed how "real" the tool felt.
What's next for VINDEX
Real contract parsing across multiple document formats, live telemetry integrations instead of static datasets, and support for tracking multiple vendors and contracts at once rather than a single demonstrated case.
Built With
- next.js
- react
- tailwind-css
- typescript
- v0