An AI underwriting platform for multifamily real estate — turning a stack of broker PDFs into a populated Purchase Template in minutes, not half an hour.
Pre/3 automates the part of the deal pipeline that quietly eats the most analyst time: pulling structured financial data out of Operating Memorandums, T12s, and Rent Rolls and dropping it into the firm's Purchase Template. Each broker formats things differently; every deal used to be a manual translation job.
The platform pairs agentic extraction with human-in-the-loop review — autonomous where the data is unambiguous, escalating to a person the moment confidence drops. A persistent memory layer learns broker-specific quirks so repeat deals get faster over time.
Three stages, with a human checkpoint where it matters. Each stage is independently testable against fixtures of real broker formatting variance.
Analysts drop deal packages — Operating Memorandums, T12s, Rent Rolls — as PDFs or Excels into the dashboard. A document-type detector routes each file to the right specialist extractor; OCR handles scanned PDFs.
Structured extraction runs through LLM calls orchestrated by the Vercel AI SDK, with deterministic parsers for Excel grids. Line items are mapped into Pre/3's 12-category expense structure; low-confidence mappings are flagged rather than guessed at.
Underwriters review flagged items and apply corrections through a streaming AI-assisted UI. Corrections feed back into agent memory so the system learns broker formatting patterns. The output is a populated Purchase Template with formulas and references preserved.
Two services, one shared store, a deal package walking from raw broker files to a populated analyst workbook. Each stage is independently testable; nothing commits without a confidence pass and a human checkpoint on the edges where it matters.
PDFs and Excel files land in Supabase Storage; a deal row is created in Postgres. Auth scopes everything to the analyst and their firm.
The file detector inspects each upload — sometimes by header signature, sometimes by content — and tags it as Operating Memorandum, T12, Rent Roll, or unknown, then routes to the right extractor.
A Python microservice on Railway handles document parsing: pdfplumber for text PDFs, OCR for scanned, openpyxl for Excel grids. Returns raw structured data tailored to the document type.
The TypeScript orchestrator calls the LLM with the raw extraction, applies Pre/3's 12-category mapping, and gets back structured fields with per-line confidence scores. Low-confidence rows are tagged.
Validated rows persist to Supabase. Broker-specific formatting patterns and prior corrections flow into Letta agent memory so the next deal from the same broker starts smarter.
The analyst opens the deal; flagged fields surface first. A streaming chat lets them ask the agent about specific cells. Corrections write back through the orchestrator and trigger a memory update.
The Excel template is regenerated with formulas and cell references intact, the extracted data slotted into the firm's standard layout. Analyst downloads a workbook that looks like the ones they've always used.
Low-confidence mappings are surfaced for review rather than silently committed. Underwriters keep full control over the final output; the system learns from every correction.
Per-document-type extractors outperform one-size-fits-all prompts on broker-format variance. Each extractor is independently evaluable, so accuracy regressions can be traced and tested.
Letta persists categorization patterns and broker-specific quirks. Repeat deals from familiar brokers process faster and need less review over time.
Every deal lands in the same 12-category expense structure and Purchase Template format, so analysts can compare deals directly and the firm builds a proprietary deal database as a side effect of normal work.
Ask Iris about Pre/3, the rest of my work, or how to reach Chris directly.
Talk to Iris →