- Vitru is a spin-off of ADAIA, an AI consulting and venture-building firm. It grew out of a real engagement with an architecture and engineering firm in Dubai.
- QA/QC costs a firm three times over: internal review hours, specialist time pulled off billable design work, and external delays when errors surface at approvals instead of in the model.
- Catching an error inside the model, before it reaches a drawing set or a submission, is what keeps it cheap to fix. But building AI that does this well runs into three hard problems: AI is expensive to run at scale, firm and code rules are hard to ingest, and AI is not always right.
- Our fix: delegate the expensive reasoning to sub-agents under our own delegation protocol, then have the AI write deterministic rule scripts that run natively inside Revit — fast, cheap, and repeatable on every model after that.
- Those agents need memory that persists across projects. We built workspaces — a versioned file system agents and humans both use to scope and track a firm’s rules over time.
Where this comes from — and what ADAIA is
If the name Vitru rings a bell but ADAIA doesn’t, here’s the short version: ADAIA is an AI consulting and venture-building firm. One half of the business is hands-on AI consulting — strategy, infrastructure, and build engagements for companies across industries. The other half is building and operating our own AI-native ventures out of what we learn on those engagements. Vitru is one of those spin-offs.
It didn’t start as a product idea. It started in 2025, when we partnered with an architecture and engineering firm in Dubai. We ran a pre-implementation workshop with them to surface where their quality workflow was actually losing time, and the pain was consistent: model errors were being caught by hand, late, by their most senior people, on every project.
Out of that engagement we defined and built a QA/QC AI agent working directly against their Revit models — a system with a Revit connector, an agentic layer, a multi-agent work-parallelization system, and a building-codes-and-rules ingestion pipeline. It cut issues in their engineers’ work by roughly 60% and cut rework cycles by about 40%.
That result is what convinced us this wasn’t a one-firm fix. We productized it as Vitru, and we’ve kept talking to other AEC firms since — architects, BIM managers, engineering leads — and the same complaint keeps surfacing, almost word for word, regardless of firm size or region: QA/QC is broken, everyone knows it, and nobody has fixed it.
This post is about that pain, what we think is actually going on underneath it, and what we’ve built at Vitru to close the gap.
What QA/QC actually costs a firm
“QA/QC” sounds like a back-office function. In practice, it’s one of the largest hidden line items on every project.
Avoidable design errors consume up to 21% of project turnover, according to the Get It Right Initiative. Autodesk and FMI put the global cost of construction rework at $88 billion in a single year. Roughly half of building code provisions are too ambiguous to automate outright, per ASCE research — which means the other half is exactly the kind of repetitive, rules-based checking a computer should be doing, and mostly still isn’t.
Here’s why the number is so large: QA/QC losses aren’t one cost. They’re three.
1. Internal time losses
Every model gets checked by hand before it goes anywhere — by a BIM manager, a project architect, sometimes both. That’s hours per model, every revision, on every project, and it doesn’t scale with headcount. It scales with the number of models you’re running.
2. Specialist time losses
The people doing that checking are usually your most senior, most billable staff. Every hour a project architect spends verifying door clearances is an hour they’re not spending on design decisions only they can make. This is the cost most firms feel but rarely put a number on.
3. Indirect efficiency losses
Standards drift. Naming drifts. Every model bends the firm’s conventions a little, and the drift compounds across a project’s lifetime — sheet setup, family naming, worksharing habits — until cleanup becomes its own project.
4. External losses — delay at approval
This is the one that shows up on a schedule. An error caught by hand two weeks before submission is a fire drill. An error caught by the reviewing authority after submission is a resubmission cycle — and increasingly, that reviewing authority is running automated checks of its own. Singapore’s CORENET X, mandatory for large projects since October 2025, reportedly cut approval times by more than half by checking submitted BIM models automatically. Honolulu cut reviewer time per plan from 60–90 minutes to 15–20. If the regulator is running automated logic on your submission, waiting for them to find your errors is the most expensive way to find them.
The solution: AI that plugs into Revit and checks the model against the rules
Here’s the distinction that matters most, and the one most “AI compliance” tools get wrong: there’s a real difference between AI that reads code and AI that checks your model.
An AI that reads code well is not the same as an AI that can check your model.
Reading code well — answering “what does the egress requirement say” — is a research problem. Useful, but it doesn’t tell you whether your building complies. Vitru works differently: it opens your actual Revit file, walks the actual elements — the door you drew, the stair you sized, the room you laid out — and evaluates each one against a ruleset. Every finding traces back to a specific element ID, not a paragraph of code.
That’s the version of “AI QA/QC” that actually replaces the manual review, because it’s checking the same thing the manual review checks: the model itself, as it actually exists, before anything gets exported, printed, or submitted.
The pain of actually building this
Saying “just have AI check the model” is easy. Building it is where three real problems show up.
AI is expensive. Running a large model’s worth of judgment — a full frontier-model reasoning pass — against every door, wall, and stair in a real Revit file, on every revision, on every project, does not scale economically. Do the math on running that at firm scale and the unit economics stop working fast.
Rules ingestion is hard. A jurisdiction’s code is not a clean spec. It’s ambiguous in places, cross-references itself, has been amended piecemeal for decades, and none of it arrives in a format a machine can execute directly. Turning “clear width shall not be less than 32 inches” into something a script can evaluate against real geometry — correctly, including the geometry a naive parameter read gets wrong — is the actual engineering work.
AI is not always right. A model that hallucinates a violation, or misses one, is worse than no check at all, because it trains your team to stop trusting the tool — and once trust is gone, nobody looks at the findings, and you’re back to manual review.
Our approach
We built around those three constraints directly, not around wishing them away.
Check inside Revit. We connect directly to the live model, so every check runs against the same data your team is actually working in — not a static export generated after the fact.
Delegate to sub-agents, because full AI reasoning on everything is too expensive. We don’t run one expensive model against the whole file. We built our own delegation protocol that routes work to specialized sub-agents scoped to a narrow task — cheaper, faster, and easier to get right than one generalist agent trying to do everything.
Let AI write the deterministic scripts, then run the scripts — not the AI — on every model. This is the core unlock on cost. The expensive reasoning happens once, when a rule is being authored: AI interprets what a firm standard or code clause means and writes a deterministic rule script for it. After that, checking a model against that rule is just running a script — near-zero marginal cost, completely repeatable, and it either passes or it doesn’t. No hallucination risk on the checking pass, because the checking pass isn’t an AI judgment call anymore.
Give the system memory, because a rule set that resets every project is worthless. We call this layer workspaces: a file system where both agents and humans can spin up a new subfolder for a distinct area of memory — a jurisdiction, a client standard, a project type — and every change to it is versioned, so there’s an actual timeline of how a firm’s rules evolved and why. A firm’s quality standards stop living in one senior reviewer’s head and start living in a system the whole team inherits.
Run those four together — model-aware checking, cheap deterministic scripts authored by delegated sub-agents, and versioned memory in workspaces — and you get something that’s cheap enough to run on every model, on every revision, and trustworthy enough that people actually look at what it finds. That’s the same architecture behind the results from our original Dubai engagement — roughly 60% fewer issues and 40% less rework — now running across a library of 180+ rules, in minutes instead of hours.
Try it on your own Revit model. Download the add-in and run a QA pass, or book a demo and we’ll set up your first rule package with you.
Download the add-in Book a demo →
What’s next
Two directions, both extensions of the same architecture.
More agents, other use cases. QA/QC was the front door because it’s the pain every firm named first. The same delegation-and-workspaces architecture extends outward — each new agent shipped honestly labeled by maturity rather than oversold as done:
- Beta Accessibility compliance checking — door widths, ramp gradients, turning circles
- Labs Sustainability / rating-system compliance — LEED v4.1, Estidama Pearl, Passive House PHPP
- Labs Brand / client-standards enforcement — title blocks, view templates, naming
- Roadmap Interoperability agents — translating Rhino and SketchUp geometry into native Revit elements
Taking QA/QC to the extreme. Two specific bets: covering the full breadth of jurisdictional codes, not just the ones we started with, and improving the algorithm that turns a rule description into a test — so rule authoring itself gets faster and more reliable as the system sees more of a firm’s standards.
FAQ
Is this checking my drawings or my model?
The model. We connect to your live Revit file and evaluate the actual elements — not a PDF or a sheet set generated from it.
What’s the relationship between ADAIA and Vitru?
ADAIA is the AI consulting and venture-building firm behind Vitru. Vitru started as a client engagement — a QA/QC agent built for an architecture and engineering firm in Dubai — and became a standalone product once we saw how much it moved the numbers.
Does this replace my BIM manager?
No. It gives them leverage. Your BIM manager authors the rules once; the system enforces them on every model after that. The judgment stays human — the repetitive checking doesn’t have to.
Why not just run a big AI model against the whole file every time?
Cost and trust. Running full AI reasoning against every element, every revision, on every project doesn’t scale economically, and it reintroduces the “AI is not always right” problem on every single check. Deterministic scripts, authored once by delegated sub-agents, solve both.
Who’s liable if the AI misses something?
The architect or engineer of record, always. This is decision-support — it finds, explains, and recommends. The licensed professional reviews and signs off.
How does the system “remember” a firm’s standards over time?
Workspaces — a versioned file system where a firm’s rules for a jurisdiction, client, or project type live in their own scoped area, with a change history. Nothing resets between projects.
The takeaway
Every hour your senior staff spends manually checking a door width is an hour they’re not spending on the decision only they can make. The firms that fix this first aren’t doing something clever — they’re doing something the software industry figured out decades ago: catch it once, write it down as a permanent, cheap, automatic check, and never manually catch that same thing again.
Start with one model. See what it catches. Book a demo and we’ll run a QA pass with you.