Dashboard
Contract Risk Scoring
Ghost PO Watchlist
Why This Vendor?
Call Simulator
Collusion Graph
Audit Trail

Inspiration

Construction procurement runs on a strange kind of blindness. Contracts get signed by people who don't have time to read all fourteen pages. Purchase orders sit quietly until an invoice arrives and suddenly there's a dispute nobody saw coming. Vendors get chosen off a spreadsheet ranking that nobody can actually defend to their own leadership. And every so often, three "competing" bidders turn out to be the same operation wearing different names — and nobody notices because nobody's looking at the relationships between vendors, only the paperwork of each one in isolation.

Kaya AI's own framing of the Procurement track — "what would it look like if every team had an expert analyst working 24/7" — is what crystallized the idea for us. Most tools in this space stop at reading documents faster. We kept asking: what does an actual analyst do that a document-reader doesn't? An analyst reads a contract and tells you before you sign that a clause is dangerous. An analyst notices a vendor is trending toward a dispute before the invoice lands. An analyst can explain, out loud, why one bid beat another — and knows when something about three bidders just smells wrong. That gap between "extracts information" and "exercises judgment" is where Meridian lives.

What it does

Meridian is an AI procurement analyst built around five connected capabilities that all share one grounded source of truth — nothing is asserted without a citation back to its exact origin.

Contract Risk Scoring — reads a draft contract clause-by-clause before signature and produces a 0–100 risk score, surfacing the specific clauses driving it (an uncapped one-way indemnity, an asymmetric termination right, an unbounded price-escalation clause) with plain-English reasoning and a page citation for each.
Ghost PO Watchlist — predicts which active purchase orders are heading toward a dispute or delay, weeks before the delivery date, using vendor late-delivery history, order-size deviation, and — critically — signals inherited directly from the contract engine, so a risky payment clause feeds forward into the PO's risk score automatically.
Why This Vendor — compares bids with a transparent, rule-based rubric instead of a black-box rank, and generates a live counterfactual: exactly which criterion, and by how many points, would flip the decision. Drag a score and watch the ranking recompute instantly — deterministic arithmetic, not another LLM guess layered on top of a guess.
Vendor Negotiation Simulator — transcribes a vendor call in real time and cross-references what's being said against the same grounded contract clauses, catching a spoken contradiction (a vendor verbally claiming 30-day payment terms when the signed contract says 15) mid-conversation, out loud, with the citation.
Vendor Collusion Detection — surfaces bidders that shouldn't be behaving like independent competitors: shared submission IPs, shared bank accounts, shared registration addresses, synchronized bid timing — rendered as a relationship graph and, more viscerally, as an actual map of vendors' registered locations in and around Chennai, so a shared-address cluster is something you can literally see.

Every one of these speaks the same language of evidence. Click any score, any flag, any recommendation, and it opens the exact clause, data point, or shared signal it came from — plus a full audit trail underneath all of it.

How we built it

The backbone is a FastAPI backend with Gemini 2.5 Flash doing the reasoning-heavy work — clause classification, rubric-based vendor scoring, and reasoning generation for the risk drivers — paired with PyMuPDF for document parsing (with an OCR fallback for scanned contracts) and pgvector/ChromaDB-style embeddings for line-item and clause similarity matching.

We deliberately kept the counterfactual engine and the vendor-ranking recompute rule-based rather than LLM-generated — adjusting a rubric score triggers plain arithmetic, not another model call. That decision mattered twice over: it makes the live demo deterministic and fast (no waiting on an API mid-presentation), and it makes every ranking flip explainable as "criterion X changed by Y points," not "the model decided differently this time."

The frontend is a single-page React app styled as what we started calling an "analyst's control room" — a consistent design vocabulary where blueprint-blue is reserved exclusively for citations, risk tiers get their own color language (low/medium/high), and monospace type is used specifically for evidence: clause references, IDs, signal names. That consistency turned out to matter a lot for trust — once a person learns that blue means "click me, I'm a citation," they start expecting it everywhere, and we made sure that expectation was never broken.

Voice ended up threading through more of the product than we originally planned. The Dashboard opens with a spoken morning briefing (real browser text-to-speech, not a pre-recorded clip), there's a live mic-query mode on the Contract Risk screen that answers questions out loud with on-screen citations, and the Negotiation Simulator's contradiction alert is genuinely spoken in real time as it's detected — not narrated over afterward.

For the Collusion Detection map, we used Leaflet with OpenStreetMap tiles plotted over real Chennai-region industrial areas (Ambattur, Sriperumbudur, Oragadam, Guindy) with synthetic vendor registration data layered on top — including a dashed-circle callout around two "competing" bidders who turn out to share one registered plot.

Challenges we ran into

Keeping the demo deterministic while it still looks alive. Live TTS, live map tiles, and live slider-driven recomputation all introduce real failure surfaces during actual judging — an unmuted-browser dependency here, a network call to a tile server there. We solved this by making sure every "live" moment has a fallback: captions render even when speech synthesis is unavailable, and the underlying pipeline logic (STT → contradiction check, slider → recompute) runs the same way regardless of whether the flashier layer on top succeeds.

Not letting five features become five disconnected demos. Early versions felt like a features list rather than one system. The fix was architectural, not cosmetic: the contract engine's clause store had to be the single thing every other mode reads from — the Ghost PO watchlist cites the same clause 3.4 that the Negotiation Simulator later catches a vendor contradicting, and the same clause 5.1 that suppresses a vendor's rubric score in Why This Vendor. Once every mode was provably reading the same data, the product stopped feeling like a bundle and started feeling like one analyst.

Being honest about synthetic data without looking hollow. We don't have access to real construction ERP feeds or real vendor registries in a hackathon window. Rather than pretend otherwise, we built the synthetic datasets to contain deliberately planted known-answer cases — a real collusion cluster to find, a real contradiction to catch — and said so explicitly in the product itself (a permanent "simulated dataset" badge in the UI) rather than letting a judge discover the truth and wonder what else was overstated.

Rule-based versus LLM-based counterfactuals. It was tempting to let an LLM generate the "why this vendor" explanation directly — it's easier to build and sounds more sophisticated. We deliberately chose arithmetic instead, because a counterfactual a judge can drag a slider and verify themselves is worth more than a fluent explanation they have to take on faith.

Accomplishments that we're proud of

Getting five distinct analytical capabilities to share one grounded evidence layer, so nothing in the product ever asserts a number without a clickable source behind it.
Making the negotiation-catch moment — a spoken contradiction alert firing in real time against a call transcript — actually work live, not as a scripted animation pretending to be real-time detection.
Choosing prevention and prediction (pre-signature risk, pre-dispute PO flags) over the reactive reconciliation-after-the-fact approach that we expect most of the field to build, while still being honest that our datasets are realistic simulations rather than production feeds.
Turning an abstract fraud signal (shared IP, shared bank account) into something a judge can see on an actual map of Chennai's industrial corridors, rather than leaving it as a table row.

What we learned

We learned that "explainability" is worth very little unless it's also interactive — a citation you can only read is different from a citation you can click, and a score you can only see is different from a score you can drag and watch recompute in front of you. We also learned, the hard way, that stacking multiple "live" technical demonstrations (voice, maps, real-time recomputation) into one demo multiplies your fragility risk just as fast as it multiplies your wow-factor, and that the discipline of building a graceful fallback for every live element is not optional polish — it's the difference between a memorable demo and a broken one in front of judges.

What's next for Meridian

Replace the synthetic vendor-history and bid datasets with a real ERP/vendor-registry integration — the architecture was built from day one to accept a live data feed without redesign.
Extend the Vendor Collusion Detection engine beyond IP/bank/registration overlap into more subtle statistical bid-pattern analysis (e.g. detecting systematic "just above the leading bid" pricing across a longer tender history).
Turn the Negotiation Simulator from a scripted demo into a real telephony-integrated feature, so the same live contradiction-detection pipeline runs on genuine vendor calls rather than a pre-scripted clip.
Add a bias/conflict-of-interest layer that audits the procurement team's own decision patterns — not just the vendors — for favoritism or bypassed review thresholds, extending Meridian's "integrity" framing from external fraud to internal process health as well.