Does AI Hallucinate on Real Estate Numbers? How to Keep AI Underwriting Accurate | NextAutomation

The Short Answer

Yes. A raw chat model can hallucinate a number on a deal, and if you have pasted a rent roll into a chat window and asked for an underwrite, you have probably already seen it invent an occupancy figure or transpose a line item. That is the honest starting point, and it is exactly what operators tell us. One who had tried the DIY route put it plainly: the "current tools like Claude are too unreliable, requiring constant manual fixes." Another described a self-built stack that "lacks reliability and tracking." They are not wrong.

But that is a statement about using a chat window as your underwriting tool, not about whether AI can be trusted with deal numbers at all. A serious CRE AI system is architected specifically so that when the model does slip, the mistake is caught before it matters. The difference is not a better model or a cleverer prompt. It is the plumbing around the model. This piece explains why raw chat use hallucinates on deal figures, how a production system is built so it cannot quietly ship a made-up number, and the exact questions to ask a vendor, or your own DIY setup, to confirm the safeguards are real.

The Question Operators Actually Ask

This is the objection that comes up before anyone talks price. In two separate conversations on our own site, operators walked straight into the liability question, unprompted. One session ran: "waht about liability with sensitive data", then "so you are not liable?", then "what if your system messes up?" In a second, independent session, someone asked the same core thing again: "what if your system fails." A third put it as the underlying trust question: "why should I trust you?"

Those are the right questions. An underwriting mistake is not a typo in a blog post; it is a wrong cap rate in a memo the investment committee votes on. So the correct response is not "our AI is very accurate." It is to show the architecture that assumes the model will occasionally be wrong and is built to catch it. Reliability worry is a recurring theme, not a fringe one, and the honest answer is a design, not a reassurance.

Why Raw Chat Hallucinates on Deal Numbers

A language model is a text generator. When you paste an offering memorandum into a chat window and ask for an underwrite, you are asking one system to do two very different jobs at once: read specific figures out of a document, and generate fluent prose. The generation objective is what makes the output read well. It is also what makes the model, when a figure is unclear or missing, produce a plausible-sounding number instead of stopping. It is not lying; it has no concept of a source of truth. It is completing a pattern, and a confident wrong number completes the pattern just as well as the right one.

Three failure modes show up repeatedly in a chat-only workflow. The model transposes or rounds a figure while restating it. It fills a gap: if the T-12 does not clearly state a number, a raw model will often invent a reasonable-looking one rather than flag the absence. And it loses the thread across a long document, attributing one property's expenses to another. None of these are caught by the model itself, because the model has no separate step that compares what it wrote against what the document actually said. That missing step, not the model's raw error rate, is the real problem. Which is also the good news: the fix is architectural.

How a Production System Prevents It

A CRE underwriting system built to be trusted does not ask the model to "underwrite the deal" in one pass. It breaks the job into steps, and puts a deterministic guard between the AI and anything a human relies on. Here is the pattern, drawn from how our public deal-intake systems are built.

1. Extraction into a structured record, not freeform generation

The first job is narrow: read the broker email, OM, T-12, or rent roll and pull the property, tenancy, and financial fields into a structured record. The model is not asked to write an analysis here; it is asked to populate defined fields. That constraint matters. Extraction into a fixed schema is a far more contained task than open-ended generation, and it makes every value auditable, because each figure now lives in a named field you can point at, rather than being buried in a paragraph of prose. You have turned "trust the narrative" into "check the fields."

2. Every memo figure traces to a source field

When the system later drafts the investment memo and the asset business plan, those documents generate from that same structured snapshot. Every figure in the memo traces back to a specific field in the record, and because the memo and the business plan are built from the identical snapshot, they never disagree with each other. This is the difference that kills the hallucination-in-the-memo scenario: the drafting step is not free to invent a new number, because it is assembling from a fixed set of extracted values, not generating figures from scratch. If a number is in the memo, you can trace it to the field it came from.

3. A deterministic completeness check flags the gaps

Extraction is the AI step, so it is exactly where a field can get missed, and this is the honest weak point every serious system has to account for. The backstop is not another model; it is a deterministic rule. In our public deal-intake system, a 26-point completeness checklist runs on every inbound deal and flags anything the model missed. It is pure rule-based logic: it checks whether each required data point is present and surfaces what is absent. That directly addresses the worst raw-chat failure mode, where the model silently fills a gap. Instead of inventing a number for a missing figure, the system flags the gap for a human to resolve. A machine that says "this field is empty" is worth more than one that guesses.

4. Drafts are labeled drafts, and a human approves before committee

The output of the AI steps is a draft, and it is treated as one. Human review is a built-in stage, not an optional courtesy: the committee reads an analyst-approved document, never raw model output. The AI screens, scores, and drafts; a person confirms the figures and owns the conclusion. The system does not make the investment decision. That is the human gate, and it is where the chain of safeguards resolves: extraction into fields you can audit, a completeness check that flags what is missing, drafting that only assembles from extracted values, and an analyst who signs off before anything reaches the committee. A single number would have to survive all four to reach a vote wrong, and each layer is designed to stop it.

The Self-Check: Questions to Ask Any Vendor (or Your Own Setup)

You do not need to see the code to tell whether the safeguards exist. Ask these, and the answers tell you whether a made-up number can reach your committee. They work just as well pointed at a DIY workflow you built yourself:

• "Does the AI extract figures into a structured record, or generate the analysis in one pass?" Extraction into defined fields is auditable. One-pass generation from a document is the pattern that hallucinates.
• "Can every number in the memo be traced back to a source field?" If yes, drafting is assembling from extracted values, not inventing. If a figure cannot be traced, it is not verifiable.
• "What flags a field the AI missed or could not find?" The right answer is a deterministic completeness check that surfaces gaps. "The model is very accurate" is not a check, and silent gap-filling is the failure you are trying to prevent.
• "When the document does not contain a number, does the system leave it blank and flag it, or fill it in?" Blank-and-flag is correct. A system that produces a plausible figure for a missing input is the dangerous one.
• "Where does a human have to approve before the numbers reach a decision?" A serious underwriting system has an explicit review gate and labels its output a draft. "Fully autonomous" is a red flag for anything a committee votes on.
• "If I hand it a scanned, badly formatted T-12, what happens?" This tests whether there is real extraction with a gap check, or a template that assumes clean input. Demo files are always tidy; your deal flow is not.

The Real Blocker Is Data, Not the Model

Zoom out and the field data says the same thing. More than 60% of investors remain strategically, organizationally, and technically unprepared to scale AI beyond pilots (per JLL 2025 Global Real Estate Technology Survey, October 28, 2025). And the through-line of Deloitte's outlook is that the path to AI value runs through reliable data and application readiness, not a better model (per Deloitte 2026 Commercial Real Estate Outlook, September 29, 2025). Read together, they point at the same conclusion as the architecture above: the constraint on trustworthy AI underwriting is not model intelligence. It is whether the data going in is clean and the system around the model catches what it gets wrong.

This is why "is your model good enough" is the wrong question. Models improve every few months; the reliability of the output depends on the extraction, the traceability, the completeness check, and the human gate, and those are design choices, not model choices. It is also why the chat-window approach hits a ceiling that no prompt fixes. There is no place in a chat window to put a deterministic check between the AI and your memo.

The Bottom Line

Can AI hallucinate on real estate numbers? In a raw chat window, yes, and you should not underwrite from one. In a system architected for it, a made-up figure has to get past extraction into auditable fields, drafting that only assembles from those fields, a deterministic completeness check that flags gaps, and an analyst who approves before committee. That is the difference between "the AI is accurate" (a claim you cannot verify) and "the mistake is caught before it matters" (a design you can inspect). The right worry is not whether the model is perfect. It is whether the system assumes it is not, and is built accordingly. If you want the fuller picture, see how the same discipline works step by step in a CRE underwriting workflow, decomposed, how the layers are defined in is it real AI or just automation, how the confidential-data side is handled in the CRE AI data security guide, and where the field stands in the state of AI in commercial real estate 2026.