If you read one line: Dili raised a $15M Series A this week to automate infrastructure compliance, and the durable lesson isn't the money — it's that the LLM never decides anything. The model reads the mess; a deterministic rules engine gives the verdict. In any regulated vertical, that split is the product.
The raise, in one paragraph#
On July 30, Dili announced a $15M Series A led by Khosla Ventures, taking total funding to $21.7M after an earlier $6.7M seed. The cap table is a who's-who of operators — Y Combinator's Garry Tan, Allianz, Brick & Mortar Ventures' Darren Bechtel, Rebel Fund — and co-founder Anand Chaturvedi came out of Coinbase (GlobeNewswire, FINSMES). The product automates the deeply unglamorous work of U.S. infrastructure compliance: prevailing-wage and Davis-Bacon monitoring, certified-payroll review, apprenticeship tracking, audit-ready reporting — already running across 700+ federal projects in energy, construction, and manufacturing.
That's a real business. But the reason to read it as a founder is the architecture underneath.
The pattern: model extracts, engine decides#
Here is the shape of Dili's system, stated plainly: an LLM converts unstructured records into structured data, and then a deterministic rules engine evaluates that structured data against federal rules. The model does the reading. The engine does the deciding.
That is not an implementation detail. It is the single most important design decision in any product that answers a consequential question, and most first-time builders get it backwards. They point the LLM at the whole problem — "here are the payroll records, is this project compliant?" — and let the model emit the verdict. It works in the demo. Then a hallucinated "compliant" on a Davis-Bacon audit becomes a legal exposure, not a bug you can hotfix on Monday.
A compliance verdict is auditable and legally consequential. A hallucinated "pass" is a liability, not a bug ticket.
The fix is boring and correct: let the model do the one thing it's genuinely great at — absorbing ambiguity and variance in the input — and hand the actual decision to code that gives the same answer every time and can show its work. Extraction is fuzzy and forgiving; a bad field gets caught by a schema check. The verdict is rigid and unforgiving; it needs to be reproducible and citable, which is exactly what a deterministic engine is and exactly what a language model is not.
We've made this argument before in the abstract — deterministic vs LLM orchestration is one of our most-read pieces, and the deterministic router with an LLM escape hatch is the same idea one layer up. Dili is what it looks like when a funded company bets its whole product on the split.
Why investors keep writing this check#
This is the second time in ten days we've watched the money land on this exact shape. In July's ~$1.8B agent-funding wave, the premium checks skipped the model labs and went to companies that own a regulated vertical end to end — Norm AI's "agentic law," Harvey's legal work. Dili is the same thesis in infrastructure: pick a compliance-heavy workflow where the rules are written down, and be the system that runs them at 100% coverage instead of the 5–10% a human auditor can sample.
The rules being written down is the tell. Wherever a regulation is explicit — prevailing wage, tax brackets, benefits eligibility, contract clauses — you don't want a model interpreting it. You want a model finding the facts the rule operates on, and deterministic logic applying the rule. The defensibility isn't the model (everyone rents the same ones); it's the accumulated, correct encoding of a messy domain's rules and the trust that comes from being reproducibly right.
What to copy at your own scale#
You don't need $15M to use this. The pattern scales all the way down to a weekend project:
- Draw the line between "read" and "decide." List every step in your product. The moment a step produces a consequential answer, that step is code, not a prompt.
- Constrain the extraction. Make the LLM emit structured output against a schema, and validate it. A model that returns a malformed field should fail loudly, not guess. (If you test the non-deterministic parts honestly, this is where your test surface lives.)
- Make the decision explainable. Your rules engine should return not just a verdict but the citation — which rule, which input, which threshold. That's what turns "trust me" into "here's the audit trail," and audit trails are what regulated buyers actually pay for.
The market keeps rewarding the same insight, so let it sink in: in 2026, the LLM is the cheapest, most abundant part of your stack. The durable, fundable thing is the boundary you build around it — and in a regulated vertical, that boundary is a rules engine the model is never allowed to overrule.
