One graph. Every source.
Every output, on demand.
Built AI is the AI-native operating system for institutional real estate. We take the systems you already run, Argus, Yardi, Excel, your warehouse, and bind them into a single, normalized knowledge graph of entities, documents, and cashflows. On top of that graph sits a deterministic calculation engine and an embedded analyst that can read any deal, compute any number, and author any artifact, while every external action waits for a human to approve it.
| Line ($000s) | FY24 | FY25 | FY26 | FY27 | FY28 |
|---|---|---|---|---|---|
| Gross potential rent | 13,180 | 13,640 | 14,210 | 14,690 | 15,180 |
| Vacancy & credit loss | (1,050) | (1,160) | (1,240) | (1,180) | (1,210) |
| Operating expenses | (4,820) | (4,990) | (5,210) | (5,320) | (5,460) |
| Net operating income | 7,310 | 7,490 | 7,760 | 8,190 | 8,510 |
| Debt service | (6,250) | (6,250) | (6,250) | (6,250) | (6,250) |
| Levered cash flow | 1,060 | 1,240 | 1,510 | 1,940 | 2,260 |
A real estate knowledge graph, entities, documents, and cashflows in one place
Every institutional real estate firm already has the data it needs; the problem is that it lives in pieces. The rent roll is in Yardi, the model in Excel, the valuation in Argus, the lease a PDF in a data room, and none of them can answer a question that spans all of them.
Built AI's foundation is a single normalized graph that stitches those pieces back together: funds, assets, leases, tenants, loans and covenants modeled as connected entities, not files in folders.
We model the things institutional real estate actually cares about as first-class entities, funds, vehicles, JV structures, assets, units, leases, tenants, loans, covenants, counterparties, connected to the documents that govern them and the cashflows they produce. A lease is not a file; it is a node connected to its tenant, its unit, its rent schedule, its options and its parent asset. A loan is not a row in a spreadsheet; it is a node connected to its covenants, its amortization schedule, its lender and the entity that signed it.
Once those relationships exist, questions that used to take an analyst two days collapse into a single traversal of the graph. Which assets in Fund III breach a DSCR covenant if rates move another fifty basis points? Which leases rolling in the next eighteen months sit above market, and what does re-leasing at market do to NOI and to the waterfall? Which counterparties appear across more than one position? These are graph questions, and a graph is the only structure that answers them without a human manually reconciling five systems first.
Connect → Normalize → Reason → Author
The platform runs the same four-step loop over everything it touches, and it is worth being precise about what each step does, because the rigor of the later steps depends entirely on the discipline of the earlier ones.
Connect. We integrate with the systems of record you already operate, accounting platforms, the valuation engine, scenario models, the warehouse, and with the unstructured corpus you accumulate on every deal: offering memoranda, term sheets, rent rolls, leases, loan packages, appraisals, K-1s. Nothing is migrated and nothing is replaced. The graph reads from where your data already lives.
Normalize. A lease from one landlord's template and a lease from another's describe the same economic reality in different words. We resolve those into a common schema, the same field names, the same units, the same entity identities, so that "base rent," "minimum rent" and "fixed rent" become one concept the engine can compute against. Every normalized value carries a pointer back to the exact source it came from, down to the page, the cell or the line.
Reason. On the normalized graph, the deterministic engine computes. IRRs, DSCRs, debt yields, cap rates, NOI bridges, waterfall distributions, sensitivity tables, all run as real, auditable calculations, not as a language model's best guess at arithmetic. We will spend a whole section on why this distinction is the difference between a demo and a system you can put in front of an investment committee.
Author. Finally, the platform writes, IC memos, investor letters, covenant packs, variance narratives, lease abstracts, in your templates, with your formatting, with every figure traceable to the graph node that produced it. Authoring is where the work leaves the machine and reaches a human, which is exactly why it is also where approval lives.
Every source in, every output out
A spreadsheet stores numbers. A document stores words. A graph stores relationships, and relationships are where the answers live. Every source flows into the same normalized graph, and every artifact is authored from it, cited cell by cell.
We sit on top of your stack, not instead of it
An orchestration layer that reads your systems of record and writes back only on approval. Read-then-write-on-approval, by design. See the governance →
The fastest way to lose an institutional real estate firm is to ask it to rip out a system it has spent a decade and a fortune trusting. We do the opposite. Built AI is an orchestration layer that reads from your systems of record, reasons across them, and writes back only when a human says so. Your Argus model is still the source of valuation truth. Your accounting platform is still the system of record for the books. We make them talk to each other and to the documents, we do not try to be them.
Argus
Argus stays the valuation authority. We read its projections into the graph and run scenarios against its assumptions, never overwriting it.
Yardi · MRI · Entrata
Rent rolls, GL actuals and fund accounting flow into the graph as live, normalized entities, read-only by default, so the books stay the books.
Excel
Your underwriting and waterfall models keep their logic. We map their inputs to graph nodes and run scenarios against them, one model, not two diverging copies.
The data warehouse
Snowflake, BigQuery, Databricks or your lake, connected read-only. The graph hydrates from it; any write-back is explicit, scoped and approved.
Data rooms & deal files
OMs, term sheets, leases, appraisals and rent rolls are extracted into the graph with a field-level audit trail, queryable and citable alongside your structured systems.
Your templates & channels
IC memos, investor letters and covenant packs are authored in your branded templates and staged for review, every destination is a place a human sends to, never one an agent sends from on its own.
The read-then-write-on-approval model
Connections default to read. The platform pulls from your systems, normalizes what it finds, and reasons over it, and at that point it has changed nothing in your environment. That is deliberate. An orchestration layer that can silently mutate the books, the model or the warehouse is a liability dressed as a feature. So every write, a posted reconciliation, an updated assumption, a sent letter, a row pushed back to the warehouse, is a discrete, scoped action that a named person approves before it executes. The platform proposes; the human disposes. You get the speed of an automated system with the control of a manual one, and the audit log records who approved what, when, and against which evidence.
You do not migrate, you do not re-platform, and you do not hand control of your records to a model. You connect the systems you already trust, the graph lights up across them in days rather than quarters, and the first time anything leaves read-only is the moment a person clicks approve. Adoption risk stays low precisely because the destructive surface stays closed by default.
The deterministic calculation engine
This is the part most "AI for real estate" pitches quietly skip, and it decides whether a tool is a toy or an instrument of institutional capital. At Built AI no financial number is ever produced by a language model: every IRR, DSCR, debt-yield test and waterfall tier runs on a native deterministic engine that shows its work cell by cell.
The distinction is not pedantic. Large language models are pattern machines; they generate the most plausible next token, not the correct next computation. Ask one to compound a cashflow over a ten-year hold with a mid-stream refinance and it will return a number that looks right and is frequently wrong, with no way to tell which is which. That is acceptable when the cost of an error is a clumsy sentence. It is disqualifying when the cost of an error is an investment committee approving the wrong deal, or an investor letter overstating returns to limited partners.
So we built the platform around traceability as a first principle. Every figure the system reports is backed by a calculation graph: the output cell points to the formula, the formula points to its inputs, and each input points to the exact source, a Yardi GL line, an Argus assumption, a clause on page 14 of the loan agreement, a cell in the underwriting model. Click any number in any artifact and you walk the chain all the way down to the document or system it came from. There is no opaque step, no "the model said so," no arithmetic that happened somewhere a regulator cannot follow.
The black-box problem, and why it disqualifies regulated capital
EY framed this directly in their guidance on AI in financial services: a model whose reasoning cannot be inspected, the "black-box problem", is unfit for use in regulated capital, no matter how accurate it appears on average. Institutional real estate is regulated capital. Fund managers answer to LPs, to auditors, to fund administrators, to lenders, and increasingly to regulators who expect every reported figure to be explainable and reproducible. A return that an analyst cannot reconstruct is a return that does not survive diligence.
A purely generative system fails this test by construction. You can ask it to "show its work," and it will helpfully invent a plausible-looking derivation, but that derivation is itself generated, not audited, so it provides the appearance of rigor without the substance. The deterministic engine inverts this. The work is the computation, not a story told about the computation after the fact. When an auditor asks how the Q3 NOI bridge was built, the answer is not a narrative; it is the actual calculation graph, every node of which resolves to a source.
| Dimension | LLM math you cannot audit | Built AI deterministic engine |
|---|---|---|
| How a number is produced | Generated as the most plausible token sequence | Computed by a fixed formula, identical every run |
| Reproducibility | Can vary between runs; no guarantee | Bit-for-bit reproducible from the same inputs |
| Traceability | Post-hoc explanation, also generated | Cell-by-cell chain to the source document or system |
| Audit posture | Black box, disqualified for regulated capital | Fully auditable calculation graph |
| Failure mode | Confidently wrong, silently | Surfaces missing or conflicting inputs explicitly |
- Number generated as a plausible token sequence
- Can differ between runs
- "Show your work" is itself invented
- Confidently wrong, silently
- Black box, disqualified for regulated capital
- Number computed by a fixed formula
- Bit-for-bit reproducible from the same inputs
- Cell-by-cell chain to the source
- Surfaces missing or conflicting inputs
- A calculation graph an auditor can replay
This is why the language model and the engine have strictly separate jobs. The model is the analyst's mind, it reads, reasons about what matters, decides which scenarios to run and writes the prose. The engine is the analyst's calculator, and it is a calculator the firm, the auditor and the LP can all check. Keep those two roles separate and you get the fluency of AI with the rigor of finance. Blur them, and you get a black box no investment committee should sign.
Every output the platform produces can go straight into diligence. When an LP, an auditor or a lender asks "where did this number come from," you do not defend a model, you open the trace and show the source. That is the difference between AI you can demo and AI you can underwrite on.
From a document to a decision in one pass
Follow a single document through the platform: extract, simulate, decide, every field traced to its origin. See it on a live deal →
The clearest way to see the platform work is to follow one document through it: a term sheet, an offering memorandum, a loan package or a rent roll. Built AI compresses what used to take days of manual extraction and re-keying into a single auditable pass: extract → simulate → decide.
Extract. The platform reads the document and pulls the institutional facts out of it, up to 114 structured fields from a typical deal package, covering everything from purchase price, cap rate and loan terms to lease-level economics, rent escalations, options and recovery structures. Every extracted field carries an audit trail: the value, a confidence signal, and a pointer to the exact location in the source it came from. Nothing is silently inferred; anything ambiguous is flagged for a human to confirm rather than guessed.
Simulate. Those fields hydrate the graph and the deterministic engine goes to work. IRR and equity multiple across the hold. DSCR and debt yield against the proposed financing. Occupancy and roll-over exposure from the rent roll. Then the scenarios, rate moves, re-leasing at market, an extended lease-up, a delayed refinance, a softer exit cap. Each scenario is a real computation against the same engine your firm already trusts, not a model's narrative guess at what might happen.
Decide. The output is a branded IC memo: the deal summarized, the assumptions stated, the base case and the sensitivities laid out, and every number traceable back to the clause or line it rests on. A document that arrived as an unstructured PDF in the morning is, by the afternoon, a committee-ready memo your team reviews and signs, or passes on, with the reasons on the record. The same pipeline powers the acquisitions workflow for screening and underwriting, and the asset management workflow for continuous lease and covenant monitoring once a deal is live.
- Upload, a term sheet, OM, loan package or rent roll lands in the data room.
- Extract, up to 114 fields lifted with a field-level audit trail and confidence flags.
- Simulate, IRR, DSCR, occupancy and stress scenarios run on the deterministic engine.
- Decide, a branded, fully traceable IC memo, staged for human review and sign-off.
A catalog of agents that runs the lifecycle
An analyst answers questions when you ask. An agent watches for the moment a question needs asking. Built AI ships a catalog of agents that sit on the knowledge graph and run the institutional lifecycle, from a new deal landing to a quarter-end letter going out.
Every agent does the same three things: it watches for an event, does the work on the graph, then stops and waits for a named human to approve. An agent can prepare an entire investor letter; it cannot send one.
The discipline is what keeps a fleet of autonomous workers safe inside a regulated firm. Each agent watches for a specific event, a document added, an actuals refresh, a period close. It does the work when that event fires, abstracts the lease, explains the variance, tests the covenant, drafts the letter. And then it stops. That boundary is structural, not a setting, and it is why the count at the bottom of this page that matters most reads zero.
Deal Underwriter
Extracts a new deal package, hydrates the model and runs the base case and sensitivities into a draft IC memo.
Lease Abstractor
Reads a new lease into structured terms, rent, escalations, options, recoveries, and flags anything off-market.
Variance Explainer
On new actuals, builds the NOI bridge, isolates the drivers and drafts the variance narrative line by line.
Covenant Watch
On a GL or Argus refresh, re-tests DSCR, debt-yield and LTV covenants and proposes a cure plan if any tighten.
Close Reconciler
At period close, reconciles GL actuals against Argus and the model, surfaces breaks and proposes the entries.
Investor Letter Drafter
At quarter-end, assembles performance, fund-level metrics and commentary into the firm's investor-letter template.
The numbers are the argument. Twenty-four agents in the catalog, eight deployed, twenty-four hundred runs in a week, and zero actions taken outside the tenant without a human in the loop. A platform can be busy and still be safe, but only if the busy part and the irreversible part are separated by a person. Built AI keeps that separation by design. The agents do the volume; the people keep the authority. Read how the boundary is enforced, logged and certified on the security & governance page.
Deployed in your tenant, governed on your terms
A platform that handles a fund's leases, loans, books and investor communications has to meet the bar institutional real estate sets for any system that touches capital. Built AI is built to deploy inside your perimeter and run under your policies by default, not as an afterthought bolted on for the security review.
The platform deploys multi-tenant or single-tenant, your choice: run it as a managed multi-tenant instance, or as a single-tenant deployment that is yours alone, isolated from every other customer with no shared data plane, when your mandate calls for it. It is bring-your-own-model, so the language model runs under your contracts and your controls, including fully private deployments where the model never leaves your environment. You can self-host or run on-premise when your mandate requires it, putting the entire system inside your own infrastructure.
On data: it never leaves your tenant, and it never trains any model, your leases, your rent rolls, your returns and your investor data are used to answer your questions and nothing else, full stop. Every output is 100% auditable, because the deterministic engine and the citation chain make traceability a property of the system rather than a feature you have to ask for. On certification, Built AI is SOC 2 Type II and ISO 27001, both in progress.
Multi- or single-tenant. Bring your own model. Self-host or on-prem. Data never leaves your tenant and never trains a model. Outputs are fully auditable by construction. SOC 2 Type II and ISO 27001, both in progress. The full architecture, controls and certifications live on the security & governance page.
See the platform on your own portfolio.
Bring a live deal, a fund or a stack of documents and watch the graph light up across your own systems, extract, simulate and author, with every number traceable to source. No migration, nothing leaves your tenant, and nothing acts without your sign-off.