An open-source, multi-orchestrator workspace for commercial real estate multifamily acquisitions: choose a deal, speak directly with a 31-role AI deal team over its source documents, and carry the work through diligence to an investment committee package.
Fastest proof path: run npm run proof, open the local dashboard, and trace one source-backed fact from upload to IC package. Full reviewer script: Public Proof Path.
I've been working on something that I think the CRE industry needs, and I wanted to share where it is now.
A few months ago I wrote about what happens when you point 489 AI agents at a 200-unit multifamily acquisition. That article was the bigger vision. This repo is the engineering behind the practical open-source version: the 31 named AI roles, orchestration logic, domain knowledge files, schemas, local dashboard, deterministic simulation engine, and source-backed review workflow that make the vision usable.
It is not fully production-ready. I want to be direct about that. But what is here is the most in-depth open-source framework I have seen for CRE acquisition orchestration because the category barely exists. There are agent frameworks for coding, customer support, research, and data analysis. There is almost nothing that models how a real multifamily acquisition moves across due diligence, underwriting, financing, legal, and closing while preserving data handoffs, review gates, and investment committee evidence.
The project is local-first: you can select a deal, choose the right specialist, and keep a durable source-backed conversation over its documents; you can also run the proof path with no API keys, inspect uploaded tables and source rows, review extracted candidate fields with provenance, approve or waive ambiguous values, and export Markdown/JSON for an investment committee starter package. The dashboard's workflow runtime defaults to live ChatGPT/Codex (with web search on) so the team can pull and cite real market, lender, and environmental data, while the deterministic offline demo stays the no-credential public proof path for tours, screenshots, and CI.
Everything in here - the agent prompts, domain skills, schemas, pipeline architecture, dashboard, and demo artifacts - is yours to use as a starting point. Fork it. Build on it. Adapt it to your own deals, investment thesis, and internal acquisition workflow. If this framework helps even one CRE team rethink how they approach acquisitions, it was worth open-sourcing.
Let's bring this industry into the future.
Disclaimer: This project is a reference architecture and educational framework, not production software for making investment decisions. Nothing here is financial, legal, or investment advice.
- Start by asking the deal team: on the Conversation Desk, choose a deal, search for the right role, select the documents that belong in scope, and ask. Open a retained thread from the left rail when you want to continue where you left off.
- Prove the trust loop first: run
npm run proofand follow the Public Proof Path from source document to uploaded data inspector to extraction review to approved evidence to workpaper to IC package. - Run a first real deal in 10 minutes: follow the First Deal Guide, start the dashboard, drop local rent roll/T12/offering memo files, review source-backed fields, and export the IC starter package.
- Trace the source-to-IC proof path manually: use the Demo Journey to follow a value or red flag from document drop, through uploaded data inspection, extraction review, approved evidence, workpapers, and the IC package references the current artifacts expose.
- Use Parkview as the deterministic fallback: from the chat-first Conversation Desk, click New Deal, then Start Guided Demo for a no-upload sample tour through the lifecycle spine, command bar, Your Team, live feed, and IC package.
- Install from scratch: follow Quick Start. The dashboard path is local-first, launches live Codex workflows by default, and keeps the sample tour deterministic.
- Choose the right runtime: read Live Codex Agents vs Offline Demo - live Codex is the default launch lane and the offline demo is the no-credential fallback - before sending any real deal context through Codex.
- Understand the system: read Architecture, Agent Catalog, API Reference, and WebSocket Events.
- See where to contribute next: review the Roadmap, especially richer live runtime controls, deeper legal-document parsing coverage beyond the shipped PSA/title/estoppel candidate extraction, OCR hardening, and additional messy parser fixtures.
For the guided path, use First Deal Guide. For the shortest deterministic demo, use Quick Demo.
- Chat-first Conversation Desk - choose a deal, search the 31-role deal team, pick a specialist, and ask questions in plain English without first navigating a workflow console.
- Durable, deal-scoped threads - each conversation keeps its selected documents, messages, citations, activity, and agent identity after reload; deal, agent, and thread state can be restored directly from the URL.
- Source-backed answers - agents answer from the selected local deal documents, expose the exact citation evidence available to the runtime, support follow-ups, and keep retry/cancel state visible without silently launching a workflow action.
- Document-first deal intake - upload rent rolls, T12s, offering memos, PDFs, and supporting files into a local workspace.
- Uploaded data inspector - see uploaded tables, field types, fill rates, examples, source rows, and click-through row detail before applying extracted values.
- Source-backed extraction review - supported XLSX/CSV/TXT/MD, text-based PDF sources, and readable scanned/image-only PDFs become candidate fields with confidence, warnings, file hashes, and source-location (sheet/row/column or page) provenance; OCR-derived fields stay review-gated before they can change deal inputs.
- Human approval gate - underwriting inputs do not change until the operator approves/applies trusted fields or waives/rejects ambiguous ones.
- 31-role AI deal team - 6 orchestrators, 21 acquisition specialists, and 4 document-ingestion roles are defined as markdown prompts.
- Visible coordination - dashboard events show specialist messages, handoffs, dependencies, reviews, workpapers, and package status.
- Two runtime paths - live ChatGPT-authenticated Codex is the default workflow runtime (Workflow Launcher, Swarm Goal Console, and presets default to Codex, all agents selected, concurrency 2) and runs with web search on by default so agents look up and cite real comps, rents, cap rates, demographics, and rates; an explicit offline deterministic simulation remains the no-credential fallback for demos, screenshots, and CI-safe validation.
| AI Roles | Skills | Schemas | Workflows | Fixtures | Test commands |
|---|---|---|---|---|---|
| 31 | 8 | 28 | 5 | 40 | 14 |
Counts reflect the current checked-in catalog: 25 specialist prompt files plus 6 orchestrators; 8 domain knowledge files; 28 JSON Schema contracts; 5 workflow definitions; 40 curated fixture files under fixtures/ (messy parser fixtures, legal diligence checklist extraction, lean legal-document parsing for PSA/title/estoppel, scanned OCR coverage, the adversarial real-world-pile smoke set, and the first-deal package); and 14 root test* commands tracked by package.json.
Architecture isn't accuracy. This repo ships an open evaluation harness that scores the orchestrator on synthetic deals with known correct answers and reports honest numbers — including where it falls short. Run it yourself:
npm run eval # scores the benchmark -> eval/results/{scorecard.json, TRUST-REPORT.md}It measures three layers that are NOT equivalent (full methodology + how to extend: eval/README.md; full results: eval/results/TRUST-REPORT.md):
| Layer | What it proves | Current result |
|---|---|---|
| Extraction (deterministic parsers) | recovering known fields from deliberately messy XLSX/PDF docs | precision/recall/F1 = 100% across 8/8 deals |
| Simulation (offline demo — a fixture, not reasoning) | the deterministic engine on the benchmark | determinable financials 100% (n=8) but IC-verdict only 75% exact, and it misses several narrative risks — it over-PASSes the tenant-concentration and insurance-understatement deals. It computes; it does not reason. |
| Live agent reasoning (real Codex LLM — the number that counts) | the product's actual judgment | Codex CLI 0.142.0, 2026-06-25, all 8 deals: determinable financial 100%, required red-flag recall 100%, dealbreaker recall 100%, IC-verdict 100% exact / 100% directional (8 of 8), with 0 partial agent failures. The agents genuinely flag the tenant concentration, insurance understatement, missing Phase I, leverage, DSCR, and occupancy-collapse risks the fixture cannot reason about. Honest soft spot: model-dependent returns (IRR / equity multiple) at 25% because the quick-screen agents often decline to compute forecast-style return metrics without a full scenario matrix. |
Honest scope: the benchmark is 8 synthetic deals across core-plus / value-add / distressed, with both determinable and narrative (document-buried) planted risks, and the live layer now covers all 8. Ground truth, the scorer, and tolerances are committed and fixed before runs; nothing is tuned to flatter — the live numbers re-score the real Codex workpapers, and the narrative catches were verified by reading them (e.g. "≈60% of residents work for Carolina Logistics → correlated vacancy/rollover", "only $41K/yr insurance vs a materially higher market underwrite → DSCR ~1.15x"). The honest weaknesses the report still shows: (1) the deterministic simulation is blind to narrative risk (that is exactly what the live layer is for); (2) model-dependent returns are 25% — IRR / equity multiple are genuinely assumption-driven forecast metrics, and the quick-screen live agents often do not produce them without a full scenario matrix, so this is a real limitation, not a parser bug. See EVAL-PLAN.md and eval/results/TRUST-REPORT.md for the full committed report (model, date, per-deal results, and weaknesses).
The latest public release is v3.6.0. It makes the Conversation Desk the front door, adds persistent deal-and-document-scoped conversations with any role on the 31-role deal team, and tightens the first-run, review, accessibility, and completion workflows uncovered by the full UI audit. The stable baseline remains local-first and review-first:
- Local-first - the offline dashboard, deterministic Parkview demo, and source-backed extraction require no API keys.
- Versioned release baseline -
v3.6.0adds the chat-first Conversation Desk, retained source-backed threads, searchable role picker, live conversation state, first-run and workflow repairs, and a new public walkthrough on top ofv3.5.0's Architectural Graphite product system and trust-boundary fixes. - Honest evaluation -
npm run evalscores the orchestrator on an 8-deal synthetic benchmark and reports honest numbers including where it falls short (see Honest Evaluation). The live (Codex) layer covers all 8 deals; the current verified live run hit 100% IC exact/directional match, 100% determinable financial accuracy, 100% required red-flag recall, and 100% dealbreaker recall. The documented soft spot is model-dependent returns (~25%). - Known limits - the local OCR bridge supports readable scanned/image-only PDFs for review-backed headline extraction, but not arbitrary image files or fully reliable table reconstruction. Multi-tenant cloud hosting and autonomous investment decisions remain out of scope. Text-based PDF extraction, merged-cell workbooks, and single-operator self-host deployment (see Deployment) are supported.
- Local and review-gated - scanned/image-only PDFs are rendered locally with PyMuPDF, OCR'd with
tesseract.js, and converted into candidate fields that must be reviewed before applying. - Provenance-preserving - OCR output keeps file hash, page number, raw snippet, OCR confidence, parser id, warnings, and review status.
- Fail-soft - if OCR cannot read supported fields, the document remains stored with explicit OCR metadata and no guessed deal inputs.
- Verified fixture -
fixtures/parsers/scanned-offering-memo-ocr.pdfproves a true image-only offering memo excerpt can extract asking price, unit count, occupancy, and NOI through the local bridge.
See CHANGELOG.md for release history.
- Conversation Desk as the front door - the first screen now explains the three-step path directly in the product: choose a deal, choose a specialist, and ask about the selected evidence. Recent threads stay visible beside the active conversation.
- Persistent source-backed conversations - deal, agent, thread, selected-document scope, messages, citations, follow-up suggestions, active turns, cancellation, retries, and reconnection state are handled by a dedicated local conversation runtime and survive reloads.
- A searchable 31-role picker - the native browser select is replaced by a contained dark-theme picker with search, phase/role context, selected state, keyboard navigation, Escape handling, mobile bounds, and no viewport-covering OS dropdown.
- Honest action boundaries - a conversation turn answers a question; it does not silently release a workflow. Sample deals remain read-only, missing sources block sending, and the full workspace remains the explicit place for review gates, orchestration, and package actions.
- First-run and workflow audit repairs - document upload, source review, workspace handoffs, completion gating, workpaper links, status semantics, modal focus, reduced motion, and responsive chat space were audited and tightened across the complete operator journey.
- New visual walkthrough - the README now shows the Conversation Desk, agent search, New Deal upload path, a retained cited answer, and the full lifecycle workspace as one coherent start-to-finish experience.
- Architectural Graphite system - full-bleed graphite surfaces, editorial Playfair Display hierarchy, Inter interface typography, restrained copper actions, hairline structure, semantic evidence colors, and Tabler line icons replace the prior dense card treatment.
- Decision-first deal space - the lifecycle spine, phase brief, next action, ranked findings, red flags, agent activity, context rail, specialist panel, command bar, and IC package now share one quieter institutional hierarchy.
- Whole-journey consistency - the upload-first front door, Intake Deal Record, saved-deal library, deal editor, Workflow Launcher, reports, findings, error states, and completion package all use the same visual and interaction system.
- Seven trust boundaries hardened - unsafe deal IDs, preset IDs, scenario names, ingest IDs, StoryEngine IDs, legal prompt paths, and direct Codex runner deal/input-snapshot paths now fail closed before escaping their intended repository directories.
- v3.5 visual proof - all seven README screenshots were recaptured from the live facelift, including real XLSX extraction, Market Rent/source-row inspection, populated phase and IC states, specialist handoff, and authenticated Codex launch review.
- Responsive and accessible - desktop, tablet, and mobile layouts were tightened while preserving keyboard behavior, accessibility semantics, source-review gates, active-run Stop controls, exports, and operational actions.
- Pipeline verification ledger - document intake, source review, due diligence, underwriting, financing, legal, closing, IC package export, offline gates, and live Codex gates now have recorded proof in
data/status/pipeline-verification-ledger.md. - Live Codex proof gates -
npm run codex:status,npm run codex:smoke,npm run codex:run:full,npm run validate:codex, andnpm run eval:livewere run and recorded; the full live workflow completed with 21/21 agents passing on first attempt. - All-8-deal live eval refresh - live Codex agents matched all 8 benchmark IC verdicts exactly and directionally, with 100% determinable financial accuracy, 100% required red-flag recall, 100% dealbreaker recall, and 0 partial failures.
- Phase artifact hardening - underwriting writes/validates the 27-scenario matrix and IC memo; closing writes/validates the wire schedule; IC package export includes a first-class document manifest and review decision trail.
- Live manifest schema hardening - current Codex manifests validate root
agentTimeoutMsand per-resulttimedOut, so smoke/full live runs are covered by the same contract gate.
- Codex is the main workflow runtime - the dashboard launches the selected workflow on live Codex / ChatGPT by default. The Workflow Launcher, Swarm Goal Console, and saved presets default to Codex (listed first, all agents selected, concurrency 2), with the deterministic Simulation runtime kept as the no-credential fallback for demos, screenshots, and CI.
- Agents actually use web search - when Codex web search is on, agents are directed to look up and cite real rent/sales comps, submarket rents, occupancy, cap rates, demographics, supply pipeline, and current interest/lender rates. Web search is on by default with a visible toggle, and the Swarm launch and retry-failed-agents paths keep it on.
- Lean legal-document parsing - PSA, title commitment, and estoppel documents parse into review-gated candidate fields with provenance, committed fixtures, and tests.
- Intake/extraction/launch UX fixes + e2e/CI stabilization - the six intake/extraction/launch bug fixes (T12 expense magnitude, source-reconciliation equality, blocked-launch missing-field surfacing, Edit Deal step pills, sample-deal schema alignment, scoped-workflow workpaper index) land alongside dashboard overlay/modal e2e and CI stabilization.
- Production-scale local QA harness -
npm run seed:prod-local -- --count 150creates a sanitizedQA-LOCAL-2026-*150-deal corpus with source documents, extraction artifacts, approved fields, criteria, phase state, checkpoint status, and completed-report artifacts under localdata/. - Production local data regression gate -
npm run test:prod-local-datavalidates schemas, source-hash provenance, local-only output boundaries, idempotent reseeding, and generated-artifact sensitive-token avoidance. - Public proof command -
npm run proofregenerates Parkview, starts the dashboard, waits for readiness, and points reviewers todocs/PROOF-PATH.mdto trace one source-backed fact from upload to IC package. - Full QA documentation -
docs/QA-INVENTORY.mddocuments routes, roles, modals, buttons, inputs, workflows, and acceptance criteria;docs/QA-BUG-LOG.mdrecords each production-scale QA defect with reproduction evidence, fix, and verification, with 30 Playwright browser tests passing.
- Local scanned-PDF OCR bridge - readable scanned/image-only PDFs render locally with PyMuPDF and run through
tesseract.js, with no external OCR service. - Review-gated OCR candidates - OCR-derived asking price, unit count, occupancy, and NOI become candidate fields with confidence, source hash, page provenance, raw snippets, parser metadata, and human review status.
- Fail-soft scan handling - unreadable scans or scans without supported headline fields return explicit OCR metadata and warnings instead of guessed values.
- Fresh-clone OCR setup -
npm run setupinstalls and verifiesPyMuPDF; npm trackstesseract.js. - OCR fixture proof -
fixtures/parsers/scanned-offering-memo-ocr.pdfverifies a true image-only offering memo can extract through the local bridge.
- Evidence-grade source-to-IC chain - IC package JSON now includes a deterministic evidence graph connecting source documents, approved fields, agent workpapers, red flags, data gaps, and package sections. Markdown export adds an Evidence Chain section.
- Fresh-clone parser setup -
npm run setupcreates.venv, installs parser dependencies fromscripts/requirements.txt, supports read-only--check, and the dashboard parser service prefers the repo virtualenv. - OCR-ready and legal diligence intelligence - scanned/image-only documents expose explicit OCR-ready bridge metadata and next action; legal/closing checklists can become review-only
diligence.checklistItemscandidates with line provenance. - Proof-path dashboard - Intake and IC Package views show the four-step Source doc -> Approved field -> Agent workpaper -> IC package path with conservative pending/ready states.
- One-command release proof -
npm run verify:v3runs release checks, root tests, parser/workspace coverage, dashboard typecheck/build, audits, offline eval, production smoke, and full Playwright E2E. CI now runs this gate too.
- One persistent "deal space" - the six-tab dashboard is replaced by a single frame: a deal header + an always-visible 7-stage lifecycle spine (Intake → Diligence → Underwriting → Financing → Legal → Closing → IC) + a context-sensitive center stage + a right rail (live feed + "Your Team") + a command bar. Power-user controls (runtime/Codex limits, criteria, presets, mission control, logs, recovery) move into an Advanced drawer.
- Intake with no manual entry - drop the rent roll, T12, and offering memo and the deal record auto-fills from trusted source-backed values; you only edit what the team flags, and each edit persists with provenance and an audit entry. The numbers come from your documents, not a data-entry form.
- Summon agents and watch them work - click a teammate, type a command, or tap a chip to open a slide-in panel that streams the agent's reasoning with an elapsed timer, renders its workpaper (finding / verdict / caveats) with "open full workpaper", and takes a follow-up task. Offline replays recorded work; the live Codex runtime dispatches a single agent.
- Re-presentation, not a rewrite - the redesign is the new frame plus three thin, guarded backend hooks (single-agent dispatch, inline field override, per-agent stream). The engine, schemas, agents, and source-decision audit trail are unchanged, and the deterministic offline Parkview demo stays the default public path.
- Real-world drop-flow hardening - a messy pile of T12s, rent rolls, offering memos, and junk files flows through classify → extract → review → workflow → export with no crashes, silent skips, or confidently-wrong numbers: vacant-
$0rent no longer deflates in-place averages, content-aware rent-roll/T12 classification, gracefulparse_failedfor oversized/corrupt inputs, path-redacted parser errors, and an automatednpm run test:pilesmoke test. - Threshold-driven IC verdict - the deterministic engine consults
config/thresholds.jsonfor dealbreakers and a deal-specific exit cap (fixed a clean deal wrongly marked FAIL). - Open evaluation harness -
npm run evalscores an 8-deal synthetic benchmark (withnpm run eval:offlinefor the no-API layers) and writes an honest trust report. The live (Codex) layer proves the agents catch narrative risks the deterministic fixture is blind to (red-flag recall 100%, dealbreaker recall 100%, IC verdict 100%, determinable financials 100%), with model-dependent returns (~25%) documented as an honest limit. See Honest Evaluation.
- Text-based PDF extraction - offering memos and rent rolls in PDF now produce source-backed candidate fields with per-field confidence and page-level provenance; scanned/image-only PDFs are detected, marked OCR-ready, and held for local review-gated OCR rather than silently skipped.
- Legal checklist candidates - Markdown/TXT legal or diligence checklists can produce low-confidence
diligence.checklistItemscandidates with line provenance for operator review, without auto-applying economics. - Tougher spreadsheet parsing - merged-cell workbooks are unmerged and forward-filled before header detection, image-only workbooks are flagged, and new fixtures cover currency symbols, subtotal/total rows, trailing notes, and synonym headers.
- Review-grade workpapers - workpaper quality gates (cited inputs, assumptions, calculations, caveats, reviewer signoff), per-phase evidence-completeness scoring, IC red-flag drilldowns back to the originating workpaper/source, and richer IC export with source drilldowns and package version history.
- Source-decision audit trail - timestamped approve/reject/waive history per field with cross-document conflict blocking, plus field-level provenance deep links from an approved input to its source snippet.
- Live Codex runtime hardening - per-agent retry/backoff, partial-failure re-run-only-failed-agents, secret redaction at the logging boundary, a redacted sample run manifest with its own schema, and an operator "retry failed agents" recovery action.
- Single-operator self-host deployment -
npm run serveserves the built dashboard plus the loopback API/WS together (loopback-default, not multi-tenant); see docs/DEPLOYMENT.md. - Contributor experience - an end-to-end "add a new specialist agent" guide, a dashboard architecture map, and a
npm run release:checkreadiness gate.
This project has grown from agent architecture into a local-first acquisition workspace: first the orchestration catalog, then a usable dashboard, then live Codex-backed execution, document-first intake, an operator workbench, an evidence-grade source-to-IC chain, production-scale local QA, live web-backed deal work, a quieter Architectural Graphite system, and now a chat-first Conversation Desk where the operator can speak directly with any role over the exact documents selected for a deal before moving into the full lifecycle workspace.
| Release | What Changed | Full Notes |
|---|---|---|
| v1.0.0 - Initial Public Release | Published the first open-source CRE acquisition orchestration framework: markdown agents, phase orchestration, schemas, domain skills, deterministic simulation, and sample Parkview output. | GitHub Release |
| v1.1.0 - Dashboard Deal Wizard | Moved setup into the product with a guided New Deal Wizard, saved deal library, launch-ready deal flow, and Playwright coverage for key dashboard paths. | RELEASE_NOTES_v1.1.0.md |
| v2.0.0 - Operator Deal Hub | Turned the dashboard into a local-first acquisition cockpit with phase workspaces, document intake, source-backed inputs, outcome workflows, presets, and completion packages. | RELEASE_NOTES_v2.0.0.md |
| v2.1.0 - Codex / ChatGPT Workflow Runtime | Added the optional live-agent path: ChatGPT-authenticated Codex CLI execution, in-app login status, dashboard-launched Codex runs, and release-ready setup validation. | RELEASE_NOTES_v2.1.0.md |
| v2.2.0 - Document-First Acquisition Cockpit | Made the dashboard front door document-first with quick draft creation, upload-to-documents routing, compact recent deals, and a persistent cockpit sidebar. | RELEASE_NOTES_v2.2.0.md |
| v2.3.0 - Operator Workbench | Added guided deal progression, workflow readiness, upload queue recovery, source-backed change review, safer embedded launch scoping, IC review handoff, and verified public feature paths. | RELEASE_NOTES_v2.3.0.md |
| v2.4.0 - Agentic Deal Team Workspace | Reframed the dashboard around Acquisition Command, mission intent, visible agent handoffs, specialist team activity, workpapers/evidence, and IC package assembly. | RELEASE_NOTES_v2.4.0.md |
| v2.5.0 - Source-Backed Deal Intake | Turned XLSX/CSV rent rolls and T12s into persisted, reviewable, provenance-backed candidate fields operators can approve/apply before workflows use them. | RELEASE_NOTES_v2.5.0.md |
| v2.5.1 - Stale Source Evidence Gate | Added source-freshness protection to workflow launch readiness and bumped the package baseline to 2.5.1. |
GitHub Tag |
| v2.6.0 - Credibility and Infrastructure Hardening | Aligns Parkview around Austin, replaces stub workpapers, enforces strict schemas/enums, hardens local security, documents APIs/events, and refreshes public repo infrastructure. | RELEASE_NOTES_v2.6.0.md |
| v2.7.0 - Completion Pass | Closes the prior known limits (text-based PDF extraction, merged-cell/image-only workbooks, single-operator self-host deployment) and implements the ROADMAP near-term priorities: review-grade workpapers, live Codex runtime hardening, source-decision audit trail, and contributor tooling. | GitHub Release |
| v2.8.0 - Drop-Flow Hardening + Honest Eval | Hardens the real-world document-drop journey (parser confident-wrong/robustness fixes, content-aware classification, threshold-driven IC verdict, npm run test:pile) and ships an open evaluation harness with an honest trust report — live agents scored on all 8 synthetic deals, proving narrative-risk detection while honestly documenting the model-dependent-returns soft spot. |
GitHub Release |
| v2.8.5 - Deal Workspace Redesign | Redesigns the operator dashboard into one persistent "deal space" — a lifecycle spine + auto-filling intake (drop documents, edit only what's flagged) + summonable agent panels that stream work and render workpapers — as presentation plus three thin backend hooks, engine and audit trail unchanged, offline demo still the default. | GitHub Release |
| v3.0.0 - Evidence-Grade Workbench | Adds fresh-clone parser setup, OCR-ready metadata, legal checklist candidates, deterministic evidence graph lineage, proof-path dashboard UI, CI, and the full npm run verify:v3 release gate. |
RELEASE_NOTES_v3.0.0.md |
| v3.1.0 - Local OCR Bridge | Adds local scanned-PDF OCR with PyMuPDF and tesseract.js, review-gated OCR candidates, OCR fixture coverage, and setup/docs support. |
RELEASE_NOTES_v3.1.0.md |
| v3.2.0 - Production-Scale Local QA Harness | Adds a sanitized 150-deal local seed (npm run seed:prod-local), a npm run test:prod-local-data regression gate, a production-scale Playwright inventory, the npm run proof public proof command, and QA inventory/bug-log docs, plus workspace reliability fixes. |
RELEASE_NOTES_v3.2.0.md |
| v3.3.0 - Codex Main Lane + Live Web Search | Makes live Codex / ChatGPT the default workflow runtime (Simulation kept as the no-credential fallback), gives agents real, cited web search, adds lean legal-document (PSA / title / estoppel) parsing, and lands the intake/extraction/launch UX fixes and e2e/CI stabilization. | RELEASE_NOTES_v3.3.0.md |
| v3.4.0 - Pipeline Verification + Live Eval Proof | Records end-to-end pipeline verification, hardens phase artifacts and live Codex manifest validation, refreshes the all-8-deal live eval, and updates the public trust report to the June 25 live run. | RELEASE_NOTES_v3.4.0.md |
| v3.5.0 - Architectural Graphite + Trust-Boundary Hardening | Gives the complete acquisition journey an institutional graphite facelift, refreshes the public visual proof, and closes seven local path-containment gaps across deal, workflow, ingestion, runtime, and Codex inputs. | RELEASE_NOTES_v3.5.0.md |
| v3.6.0 - Conversation Desk + Persistent Agent Conversations | Makes direct, retained, document-scoped conversations with the 31-role deal team the front door; adds cited follow-ups and live turn controls; and closes first-run, workflow, accessibility, and completion gaps found in the full UI audit. | RELEASE_NOTES_v3.6.0.md |
The public demo is intentionally visual. The path begins where the operator now begins: pick a deal, choose who on the deal team should answer, and ask over the exact source documents in scope. From there it shows how new documents enter review, how evidence becomes trusted deal data, and how the same deal moves into the full lifecycle workspace and IC package.
See Demo Journey for the storyboard, screenshot refresh path, and the source-to-IC proof script a visitor can follow without a video.
The system uses a three-level hierarchy: one master orchestrator coordinates five phase orchestrators, which manage specialist agents across diligence, underwriting, financing, legal, closing, and document ingestion. The canonical open-source catalog is 31 named AI roles: 6 orchestrators, 21 acquisition specialists, and 4 source-document ingestion roles.
graph TD
M[Master Orchestrator] --> DD[Due Diligence Orchestrator]
M --> UW[Underwriting Orchestrator]
M --> FIN[Financing Orchestrator]
M --> LEG[Legal Orchestrator]
M --> CLO[Closing Orchestrator]
DD --> ING[Document Ingestion Layer]
ING --> DO[Document Orchestrator]
ING --> RRP[Rent Roll Parser]
ING --> FP[Financials Parser]
ING --> OMP[Offering Memo Parser]
DD --> RRA[Rent Roll Analyst]
DD --> OPEX[OpEx Analyst]
DD --> ENV[Environmental Review]
DD --> LTR[Legal Title Review]
DD --> MS[Market Study]
DD --> PI[Physical Inspection]
DD --> TC[Tenant Credit]
UW --> FMB[Financial Model Builder]
UW --> SA[Scenario Analyst]
UW --> ICM[IC Memo Writer]
FIN --> LO[Lender Outreach]
FIN --> QC[Quote Comparator]
FIN --> TSB[Term Sheet Builder]
LEG --> PSA[PSA Reviewer]
LEG --> EST[Estoppel Tracker]
LEG --> INS[Insurance Coordinator]
LEG --> LDR[Loan Doc Reviewer]
LEG --> TSR[Title Survey Reviewer]
LEG --> TDP[Transfer Doc Preparer]
CLO --> CC[Closing Coordinator]
CLO --> FFM[Funds Flow Manager]
Each role is a plain Markdown prompt with responsibilities, inputs, outputs, escalation paths, and handoff expectations. That is deliberate: operators and engineers can inspect the role design before trusting the runtime.
flowchart LR
U[Operator] --> UI[React Dashboard]
UI --> API[Local REST API]
UI --> WS[WebSocket Events]
UI --> CONV[Conversation API]
CONV --> THREADS[Deal-Scoped Threads]
THREADS --> SCOPE[Selected Document Evidence]
THREADS --> DEALCTX[Deal Record, Criteria, Approved Fields]
THREADS --> TURNCTX[Role Guide, Recent Transcript, Question]
SCOPE --> ANSWER[Codex Agent Answer]
DEALCTX --> ANSWER
TURNCTX --> ANSWER
ANSWER --> CITED[Citations and Follow-Ups]
CITED --> UI
API --> DOCS[Local Source Documents]
DOCS --> REVIEW[Source-Backed Extraction Review]
REVIEW --> APPROVED[Approved Inputs]
APPROVED --> SIM[Offline Deterministic Simulation]
APPROVED --> CODEX[Default Live Codex Runtime]
SIM --> WORKPAPERS[Workpapers and Phase Outputs]
CODEX --> WORKPAPERS
WORKPAPERS --> PACKAGE[IC Package Export]
WS --> UI
The conversation loop and workflow loop share the same local deal evidence but keep different authority. For a live Conversation Desk turn, the local server supplies Codex with the selected documents' extracted evidence, current deal record, underwriting criteria, approved fields, selected agent role guide, recent conversation transcript, and current question; the answer returns with server-owned citations and stays available for follow-ups. It does not release an orchestration workflow. The source-to-IC workflow remains the explicit operating loop: local source documents become reviewable candidates, approved inputs shape deterministic/offline or live-agent workpapers, and the IC package exports the available decision trail for human review. The default live Codex paths use the user's ChatGPT-authenticated Codex CLI session. Authentication is not stored in this repository.
| Phase | What Happens | Example Outputs |
|---|---|---|
| 1. Document Intake | Operator uploads source files, classifies document types, and previews parser output. | Source manifest, hashes, extraction candidates, warnings |
| 2. Source Review | Candidate fields are accepted, rejected, or waived before they become underwriting inputs. | Approved rent roll fields, T12 fields, provenance trail |
| 3. Due Diligence | Specialists review rent roll, operating expenses, physical condition, market, title, environment, and tenant credit. | Unit mix, rent roll analysis, OpEx notes, diligence flags |
| 4. Underwriting | The model builder, scenario analyst, and IC memo writer translate inputs into an investment view. | 10-year pro forma, 27-scenario matrix, DSCR, IRR, equity multiple |
| 5. Financing | Lender outreach and quote comparison turn deal metrics into debt strategy. | Loan sizing, lender quote comparison, term-sheet draft |
| 6. Legal | PSA, title/survey, loan documents, insurance, estoppels, and transfer documents move through review. | Legal checklist, estoppel tracker, PSA risk notes, closing conditions |
| 7. Closing | Closing coordinator and funds-flow manager assemble close mechanics. | Closing checklist, prorations, wire schedule, funds-flow workpaper |
| 8. IC Package | The workspace gathers outputs into a decision package. | Markdown package, JSON export, manifest, review trail |
The Parkview sample follows this path end to end with deterministic data so contributors can validate behavior without API keys or private deal files.
The full agent catalog is intentionally in the README. A visitor should be able to feel the depth of the system immediately, not after clicking through five files. docs/AGENT-CATALOG.md remains the companion reference, but the core map lives here too.
The canonical open-source catalog contains 31 named AI roles: 6 orchestrators, 21 acquisition specialists, and 4 source-document ingestion roles. The 21 acquisition specialists follow the 19-section prompt anatomy defined in Agent Development (the canonical specification), which is the authority for section names and order. The 6 orchestrators use a purpose-built orchestrator template and the 4 ingestion roles use a minimal document-parser template, so they do not follow the specialist 19-section spec.
| Phase | Starts When | Key Agents | Output |
|---|---|---|---|
| Due Diligence | Immediately | Rent Roll Analyst, OpEx Analyst, Physical Inspection, Market Study, Environmental Review, Legal & Title Review, Tenant Credit | Property risk profile, market positioning, physical condition assessment |
| Underwriting | DD 100% complete | Financial Model Builder, Scenario Analyst, IC Memo Writer | Pro forma financials, 27-scenario stress test, investment committee memo |
| Financing | UW 100% complete | Lender Outreach, Quote Comparator, Term Sheet Builder | Lender quotes, comparative analysis, recommended term sheet |
| Legal | DD 80% complete | PSA Reviewer, Title & Survey Reviewer, Estoppel Tracker, Loan Doc Reviewer, Insurance Coordinator, Transfer Doc Preparer | Contract review, title clearance, closing document preparation |
| Closing | All prior phases complete | Closing Coordinator, Funds Flow Manager | Final closing checklist, funds flow schedule, transfer execution |
Legal starts at DD 80% completion to model how real CRE deals work: legal review begins before all diligence is complete, but the Loan Doc Reviewer waits for Financing output before reviewing loan documents.
| Agent | Role | Manages |
|---|---|---|
| Master Orchestrator | Full pipeline coordinator | 5 phase orchestrators, phase dependency enforcement, final go/no-go verdict |
| Due Diligence Orchestrator | DD phase manager | 7 specialist agents, parallel launch with dependency ordering |
| Underwriting Orchestrator | UW phase manager | 3 agents in sequence: model, scenarios, IC memo |
| Financing Orchestrator | Financing phase manager | 3 agents: parallel lender outreach, sequential quote comparison and term sheet |
| Legal Orchestrator | Legal phase manager | 6 agents, early start at DD 80%, Loan Doc Reviewer waits for financing |
| Closing Orchestrator | Closing phase manager | 2 agents: closing coordinator, then funds flow manager |
| Agent | What It Does | Key Outputs |
|---|---|---|
| Rent Roll Analyst | Validates unit mix, in-place rents vs market, loss-to-lease calculation, occupancy, tenant concentration risk, and anomaly detection | Unit mix summary, rent comp analysis, loss-to-lease matrix, anomaly flags |
| OpEx Analyst | Analyzes T-12 operating statement, per-unit expense benchmarking, line-item trends, management fee validation, and tax reassessment modeling | Expense analysis, per-unit benchmarks, anomaly flags, tax projection |
| Physical Inspection | Assesses property condition, estimates capital expenditure needs by system, calculates remaining useful life, and quantifies deferred maintenance | Physical condition report, CapEx schedule, deferred maintenance estimate |
| Market Study | Reviews submarket fundamentals, demographics, employment, supply pipeline, absorption, rent comps, and competitive positioning | Market analysis, rent comps, competitive positioning, demand forecast |
| Environmental Review | Evaluates Phase I ESA findings, contamination risk, regulatory compliance, remediation cost, vapor intrusion, and adjacent property concerns | Environmental risk score, remediation needs, regulatory flags |
| Legal & Title Review | Analyzes title commitment, exceptions, encumbrances, easements, liens, deed restrictions, and HOA/CC&R issues | Title analysis, exception review, encumbrance schedule |
| Tenant Credit | Evaluates tenant creditworthiness, income concentration, lease rollover exposure, subsidy exposure, and credit scoring | Tenant credit report, concentration risk matrix, rollover schedule |
| Agent | What It Does | Key Outputs |
|---|---|---|
| Financial Model Builder | Builds a 10-year pro forma: GPI, vacancy, concessions, bad debt, EGI, OpEx, NOI, debt service, cash flow, reversion, stabilization, renovation impact, and refinancing scenarios | Base case pro forma, cash flow projections, return metrics |
| Scenario Analyst | Runs 27 sensitivity scenarios by varying rent growth, vacancy, and exit cap rate across three levels each | Scenario matrix, sensitivity tables, break-even analysis, downside risk quantification |
| IC Memo Writer | Synthesizes diligence and underwriting outputs into a structured investment committee memorandum | Investment committee memo, decision card, risk-weighted recommendation |
| Agent | What It Does | Key Outputs |
|---|---|---|
| Lender Outreach | Solicits quotes across Agency, CMBS, Life Companies, Banks, Bridge, and Mezzanine sources | Lender list, outreach results, initial quotes, lender fit scoring |
| Quote Comparator | Compares rate, term, LTV, DSCR, prepayment, recourse, rate lock, deposit, and lender fit | Quote comparison matrix, weighted ranking, recommended lender |
| Term Sheet Builder | Drafts term sheet, identifies negotiation leverage, flags non-standard terms, and models rate-lock scenarios | Term sheet draft, negotiation points, rate-lock analysis |
| Agent | What It Does | Key Outputs |
|---|---|---|
| PSA Reviewer | Reviews Purchase & Sale Agreement clauses, contingencies, representations, earnest money, closing conditions, seller obligations, and assignment rights | PSA analysis, risk flags, deadline calendar, negotiation recommendations |
| Title & Survey Reviewer | Reviews title commitment and ALTA survey for boundary issues, easements, encroachments, flood zone, and zoning compliance | Title/survey review, exception analysis, survey issue map |
| Estoppel Tracker | Manages estoppel collection and validates tenant-reported terms against the rent roll | Estoppel status tracker, discrepancy report, completion percentage |
| Loan Doc Reviewer | Reviews note, mortgage/deed of trust, guaranty, environmental indemnity, and UCC filings against the term sheet | Loan doc review, compliance check, deviation flags |
| Insurance Coordinator | Verifies lender and PSA insurance requirements, property coverage, liability, flood, windstorm, umbrella, and broker coordination | Insurance compliance report, coverage gap analysis, premium estimates |
| Transfer Doc Preparer | Prepares deed, bill of sale, assignment of leases, FIRPTA certificate, transfer tax calculations, entity verification, and closing statement review | Transfer document drafts, entity verification, transfer tax calculation |
| Agent | What It Does | Key Outputs |
|---|---|---|
| Closing Coordinator | Manages closing checklist, verifies conditions precedent, tracks outstanding items, coordinates timeline, and performs final readiness assessment | Closing checklist, readiness score, outstanding items tracker |
| Funds Flow Manager | Prepares funds flow memo, purchase price allocation, prorations, lender disbursement, escrow holdbacks, wire instructions, and closing cost breakdown | Funds flow memo, wire instructions, proration schedule, closing cost summary |
| Agent | What It Does | Key Outputs |
|---|---|---|
| Document Orchestrator | Classifies incoming documents, routes to the right parser, manages extraction pipeline, and validates completeness | Document manifest, extraction status, routing decisions |
| Rent Roll Parser | Extracts structured rent roll data from CSV, text/markdown, and supported XLSX rent rolls with operator review before apply | Structured rent roll JSON, extraction confidence, source provenance, review status |
| Financials Parser | Extracts T-12 operating statements, income line items, expense categories, and month-over-month trends | Structured financials JSON, line-item mapping |
| Offering Memo Parser | Extracts property details, investment highlights, financial projections, and market data from offering memoranda | Structured property data, financial assumptions, market summary |
| Skill File | What It Gives the Agents |
|---|---|
| underwriting-calc.md | EGI/NOI definitions, concessions, bad debt, RUBS treatment, DSCR, cap rate, IRR, sensitivity math, and worked examples. |
| multifamily-benchmarks.md | 2026 multifamily operating benchmarks, replacement reserves, and market sanity checks. |
| lender-criteria.md | Agency, bank, CMBS, debt fund, life company, bridge, DSCR, and construction lending criteria. |
| legal-checklist.md | PSA, title, survey, estoppel, loan document, entity, transfer, and closing legal review coverage. |
| risk-scoring.md | Risk severity, likelihood, mitigation, escalation, and recommendation framing. |
| checkpoint-protocol.md | Runtime status, phase dependency, and state persistence conventions. |
| logging-protocol.md | Structured event and audit trail expectations. |
| self-review-protocol.md | Agent self-checks before handoff or finalization. |
Domain files intentionally separate reusable CRE policy from individual agent prompts. When a threshold or formula changes, the goal is to update the canonical skill first, then keep agents and fixtures aligned.
The repo ships 28 JSON Schema contracts under schemas/, validated with AJV strict mode and shared enum refs.
| Contract Area | Files | Purpose |
|---|---|---|
| Shared primitives | schemas/common/ | Canonical statuses, verdicts, flags, checklist items, and agent findings. |
| Phase outputs | schemas/phases/ | Closed contracts for due diligence, underwriting, financing, legal, and closing outputs. |
| Per-agent outputs | schemas/agents/ | Agent-specific validation for rent roll, OpEx, financial model, scenario, lender, legal, and closing work. |
| Runtime checkpoints | schemas/checkpoint/ | Master and agent checkpoint persistence contracts. |
| Document manifests | schemas/documents/manifest.schema.json | Local source-document inventory, hashes, and extraction status. |
| Event payloads | schemas/events/phase-completion.schema.json | Phase completion events consumed by the dashboard and validation scripts. |
| Live-run manifest | schemas/codex/run-manifest.schema.json | Redacted Codex live-run manifest: run outcome, per-agent attempts, and failed-agent list. |
| Conversation answer | schemas/agent-conversation-response.schema.json | Cited answer, follow-up suggestions, evidence references, and honesty-gate response contract. |
| Workpaper quality gate | schemas/workpapers/quality-gate.schema.json | Workpaper quality-gate block: cited inputs, assumptions, calculations, caveats, and reviewer signoff. |
Schema validation is part of the public credibility story: extra fields fail, legacy enum values fail, and Parkview fixtures must continue to validate.
The dashboard has two connected surfaces with a clear handoff:
- Conversation Desk - the chat-first home. Choose the deal, choose or search for any role on the 31-role team, select the source documents in scope, and ask. Recent deal-scoped threads remain in the left rail; cited answers, live activity, cancellation, retry, and follow-ups remain in the main conversation. Add documents, Review sources, and Open full workspace connect the question back to the operating record.
- Full lifecycle workspace - the execution and review surface. One persistent frame stays in place while only the focused stage's body swaps. This is where operators approve evidence, release workflows, monitor the team, resolve exceptions, and export the package.
The full workspace has four fixed regions:
- Deal header - the deal name, key facts (units, price, location), and live IC-package readiness.
- Lifecycle spine - an always-visible row of the seven deal stages: Intake → Diligence → Underwriting → Financing → Legal → Closing → IC. Each stage carries a status dot (live, done, needs-your-eye, blocked, idle); clicking a stage focuses the center stage on it. The spine replaces the old six-tab nav.
- Center stage - the focused stage's body: its agents at work and the outputs they file. Intake is the opener - drop the document package, ingestion agents auto-extract, and the deal record auto-fills (trusted fields apply on read; you edit only flagged values inline, with full source provenance one tap away). The five orchestrated phases each show their specialists, streaming progress, and workpapers. IC assembles the committee package (recommendation, phase outcomes, red flags, data gaps, manifest, export).
- Right rail + command bar - a Live Feed (a chronological war-room stream of every agent's activity) and Your Team (the specialists staffed on the focused stage, with a searchable "talk to any of 31 agents" directory) sit in the rail; a persistent command bar ("Tell your team what to do…" plus context-aware suggestion chips) runs along the bottom. Clicking or directly addressing an agent opens a retained, deal-specific conversation: attach local documents, watch compact live activity, receive source-backed answers with citations, continue the thread after reload, and keep the agent's filed workpaper in view. Conversation turns are read-only unless the operator separately confirms a workflow action.
Power-user controls move off the primary path into an Advanced drawer (deal criteria/target overrides, the workflow launcher for simulation or live Codex runs, mission control, the deal-team tree, workpapers, pipeline view, story/timeline, and the partial-failure "retry failed agents" recovery panel).
The first screen is intentionally conversational, but it is not a generic chatbot. Every question is bound to a deal, an agent, a retained thread, and selected local evidence; the lifecycle workspace remains one click away for the actions that change the acquisition record.
- Node.js 18+
- npm
- Python 3.9+ for the local parser virtual environment (
pandas,openpyxl,pdfplumber,PyMuPDF) - Google Chrome or Microsoft Edge for local browser E2E, unless Playwright's bundled Chromium is installed
- Optional for live AI runs: OpenAI Codex CLI signed in with ChatGPT
From a fresh clone on Windows:
git clone https://github.com/ahacker-1/cre-acquisition-orchestrator.git
cd cre-acquisition-orchestrator
npm install
npm run setup -- --skip-codex-install --skip-login
npm run proofOpen http://localhost:5173 if the browser does not open automatically. The proof path regenerates deterministic Parkview artifacts, starts the dashboard, waits for the local UI/API to respond, and works even if Codex is missing or login is skipped.
npm run setup -- --skip-codex-install --skip-login also prepares the local parser virtual environment used for XLSX/PDF extraction without starting the optional Codex/ChatGPT auth path.
The app opens on the chat-first Conversation Desk. For the deterministic proof, click New Deal, then Start Guided Demo. For your own data, click New Deal, then Upload Source Package. Live agent chat requires the optional Codex / ChatGPT login; the Parkview proof and local document-review workflow do not.
To require a complete live-agent setup during onboarding:
npm run setup -- --require-codexCheck Codex auth status:
npm run codex:statusExpected login output should say Logged in using ChatGPT.
Run the public proof path:
npm run proofThis regenerates Parkview, starts the dashboard, opens the chat-first Conversation Desk, and points you to Public Proof Path. Click New Deal, then Start Guided Demo to inspect the deterministic sample without a Codex login.
Run the first real-deal workspace:
npm run dashboardFrom the Conversation Desk, click New Deal, then Upload Source Package. The ingestion agents extract the files and the deal record auto-fills, so you only correct flagged values before advancing through the lifecycle spine and exporting the IC package as Markdown or JSON.
Run the deterministic Parkview demo:
npm run demoVerify the offline demo path:
npm run demo:verifyRun browser E2E coverage:
npm run test:e2eRun the full verified workbench gate before a release or serious demo:
npm run verify:v3Run a small live Codex smoke test after ChatGPT login:
npm run codex:smoke| Capability | Why It Matters |
|---|---|
| 31-role acquisition team | The repo models a real acquisition desk with orchestrators, diligence specialists, underwriting, financing, legal, closing, and ingestion roles instead of one generic assistant. |
| Conversation Desk | Operators can choose a deal and agent, scope the exact documents for the question, receive cited answers, and return to retained threads without first launching a full workflow. |
| 19-section prompt anatomy | The 21 acquisition specialists follow the 19-section anatomy from Agent Development (identity, mission, inputs, strategy, outputs, checkpoint/logging/resume protocols, error recovery, dealbreaker detection, confidence scoring, downstream contract, self-review, and self-validation). Orchestrators and ingestion roles use their own purpose-specific templates. |
| Local source-package review | Operators can drop deal files into a local workspace, inspect extracted fields, review source provenance, and decide what becomes deal data. |
| Human approval gate | The system is designed around operator judgment: candidate fields are accepted, rejected, waived, or left unresolved before workflows consume them. |
| Strict schema contracts | Phase outputs, agent findings, checkpoints, document manifests, and events validate against JSON Schema with shared enums and closed objects. |
| Deterministic Parkview demo | A complete Austin/Travis County sample run produces populated reports and workpapers with no API keys. |
| Live Codex runtime (default launch lane) | Launching a real workflow uses ChatGPT-authenticated Codex CLI execution by default, with web search on so agents cite real facts; the deterministic offline simulation stays the no-credential demo/CI fallback so live AI is never required just to evaluate the system. |
| Operator dashboard | The React app pairs a chat-first Conversation Desk with the persistent lifecycle workspace: ask over selected evidence first, then open Intake-to-IC review, live team activity, workflow controls, and package assembly when action is required. |
| Public validation harness | Demo verification, parser tests, workspace tests, schema tests, security assertions, docs drift checks, and browser E2E coverage are part of the repo. |
| Open, inspectable domain layer | CRE assumptions live in Markdown skill files and JSON config, so operators can see and change the policy rather than trusting hidden code. |
cre-acquisition-orchestrator/
|-- .github/
| |-- workflows/ # release-please automation
| |-- ISSUE_TEMPLATE/ # Bug, feature, asset-type, and question templates
| `-- FUNDING.yml # Sponsorship placeholders
|
|-- agents/
| |-- due-diligence/ # 7 diligence specialists
| |-- underwriting/ # 3 underwriting specialists
| |-- financing/ # 3 financing specialists
| |-- legal/ # 6 legal specialists
| |-- closing/ # 2 closing specialists
| `-- ingestion/ # 4 source-document ingestion agents
|
|-- orchestrators/
| |-- master-orchestrator.md
| |-- due-diligence-orchestrator.md
| |-- underwriting-orchestrator.md
| |-- financing-orchestrator.md
| |-- legal-orchestrator.md
| `-- closing-orchestrator.md
|
|-- skills/
| |-- underwriting-calc.md # EGI, NOI, DSCR, cap rate, IRR, scenarios
| |-- multifamily-benchmarks.md # Multifamily operating benchmarks
| |-- lender-criteria.md # Debt sizing and lender fit criteria
| |-- legal-checklist.md # CRE legal diligence coverage
| |-- risk-scoring.md # Risk categories and scoring rules
| |-- checkpoint-protocol.md # Runtime checkpoint behavior
| |-- logging-protocol.md # Event and audit trail expectations
| `-- self-review-protocol.md # Agent handoff quality gates
|
|-- schemas/
| |-- common/ # Canonical enums, flags, checklist items, findings
| |-- phases/ # DD, UW, financing, legal, closing output contracts
| |-- agents/ # Per-agent output contracts
| |-- checkpoint/ # Master and agent checkpoint schemas
| |-- documents/ # Source manifest schema
| |-- agent-conversation-response.schema.json # Cited agent-turn response contract
| `-- events/ # Dashboard and phase-completion event schemas
|
|-- config/
| |-- deal.json # Canonical Parkview sample deal
| |-- thresholds.json # Underwriting and risk thresholds
| |-- workflows.json # Guided workflow catalog
| |-- agent-registry.json # Dashboard-readable agent registry
| |-- operator-guides.json # Operator guidance copy
| `-- scenarios/ # Core-plus, value-add, distressed presets
|
|-- dashboard/
| |-- src/
| | |-- components/ # ConversationHome, ConversationPane, workspace stages, and IC Package
| | |-- hooks/ # Conversations, deals, checkpoints, workspace, and workflow data
| | |-- lib/ # Client-side upload and form utilities
| | |-- types/ # Dashboard TypeScript contracts
| | |-- config.ts # API and WebSocket URL configuration
| | `-- App.tsx # Route shell and lazy-loaded workspace
| |-- server/
| | |-- watcher.ts # Local REST, WebSocket, file watching, and run orchestration
| | |-- conversation-manager.ts # Persistent turn lifecycle, cancellation, and event routing
| | |-- conversation-service.ts # Deal/agent/thread/message persistence and evidence scope
| | |-- parser-service.ts # Source document parsing and review candidates
| | |-- workspace-service.ts # Workspace persistence and package exports
| | |-- workflow-service.ts # Workflow catalog and readiness rules
| | |-- run-manager.ts # Demo and live-run process management
| | `-- deal-service.ts # Deal library persistence
| |-- e2e/ # Playwright browser coverage
| |-- scripts/ # Screenshot capture and dashboard helper scripts
| |-- .env.example # Dashboard runtime environment example
| |-- vite.config.ts # Vite proxy and build config
| `-- package.json
|
|-- data/
| `-- examples/
| `-- parkview-2026-001/ # Committed deterministic sample reports and workpapers
|
|-- fixtures/
| |-- first-real-deal/ # Curated starter package for local source review
| `-- parsers/ # Messy XLSX parser fixtures
|
|-- scripts/
| |-- demo-run.js # Deterministic sample run
| |-- demo-verify.js # Demo output verification
| |-- orchestrate.js # Local orchestration entrypoint
| |-- validate-contracts.js # Schema validation runner
| |-- validate-fixtures.js # Fixture drift validation
| |-- verify-doc-counts.js # README count drift validation
| |-- check-legacy-enums.js # Enum vocabulary guard
| |-- migrate-enums.js # One-time legacy enum migration
| |-- parse_excel.py # XLSX parsing bridge
| |-- lib/
| | |-- schema-validator.js # AJV strict validation wrapper
| | |-- safe-paths.js # Local path containment guard
| | |-- runtime-core.js # Checkpoint runtime helpers
| | |-- simulation-data.js # Parkview deterministic data
| | `-- workpaper-renderer.js # Markdown report/workpaper generation
| `-- *.test.* # Parser, workspace, security, goal, and lock tests
|
|-- docs/
| |-- assets/ # Current dashboard screenshots
| |-- AGENT-CATALOG.md
| |-- ARCHITECTURE.md
| |-- API-REFERENCE.md
| |-- WEBSOCKET-EVENTS.md
| |-- FIRST-DEAL-GUIDE.md
| |-- DEMO-JOURNEY.md
| |-- RUNTIME-COMPARISON.md
| |-- QUICK-DEMO.md
| |-- LAUNCH-PROCEDURES.md
| `-- TROUBLESHOOTING.md
|
|-- demo/ # Public demo scripts, one-pager, and FAQ
|-- validation/ # Expected phase outputs and validation notes
|-- CHANGELOG.md # Keep-a-Changelog release history
|-- LAUNCH.md # Launch readiness notes
|-- ROADMAP.md # Public roadmap
|-- SECURITY.md # Security policy
`-- README.md
Runtime deal data stays local and is ignored by git. The committed data/examples/parkview-2026-001/ folder is the public sample package, not a production-data pattern.
The deterministic Parkview sample is committed so visitors can inspect the shape of a finished run without needing private files or API credentials.
The workpapers are intentionally Markdown. They are easy to diff, easy to review in GitHub, and easy to convert into a more formal IC package later.
The repo is meant to be forked and adapted. Most acquisition policy lives in JSON or Markdown rather than buried in application code.
| File | Controls |
|---|---|
| config/deal.json | Canonical Parkview sample inputs: location, units, purchase price, rent roll assumptions, financing, taxes, and hold period |
| config/thresholds.json | DSCR, LTV, cap rate spread, occupancy, and dealbreaker policy |
| config/workflows.json | Guided workflow definitions shown by the dashboard launcher |
| config/operator-guides.json | Plain-English operator guidance and review-path labels |
| config/agent-registry.json | Dashboard-readable agent groupings and role metadata |
| config/scenarios/core-plus.json | Core-plus scenario preset |
| config/scenarios/value-add.json | Value-add scenario preset |
| config/scenarios/distressed.json | Distressed scenario preset |
| dashboard/.env.example | Dashboard API and WebSocket environment variables |
When adding market assumptions, lender terms, tax mechanics, or legal rules, use primary-source comments in the relevant file or mark the field as a placeholder that needs verification. The repo should be honest about what is known, modeled, and still jurisdiction-specific.
The main local gate is intentionally visible because this project is only credible if the sample deal, contracts, dashboard, and tests keep working together. For the full source-to-IC workbench proof path, run:
npm run verify:v3This runs the release drift checks, root regression suite, parser and workspace evidence tests, dashboard typecheck/build, root and dashboard audits, offline evaluation, production self-host smoke test, and browser E2E coverage.
For documentation drift:
npm run validate:docsFor fixture and schema drift:
npm run validate:fixtures
npm run validate -- --deal-id parkview-2026-001npm run validate -- --deal-id parkview-2026-001 validates a live checkpoint at data/status/parkview-2026-001.json, so run npm run demo first to generate it. (npm run demo:verify already runs this contract validation as part of its sequence.)
| Document | Use It For |
|---|---|
| First Deal Guide | Bring a local source package into review and export |
| Quick Demo | Fast deterministic demo path |
| Agent Catalog | Full 31-role catalog, skills, and schema contracts |
| Contributing a New Agent | End-to-end guide to add a new specialist agent (prompt, registry, schema, fixture) |
| Architecture | System design, hierarchy, dependencies, data flow |
| Dashboard Architecture | Dashboard UI/server component and data-flow map for contributors |
| Runtime Comparison | Offline demo vs live Codex data-sharing boundaries |
| API Reference | Local REST endpoints, request bodies, responses, and errors |
| WebSocket Events | Dashboard socket messages and run/story event payloads |
| Launch Procedures | Pipeline launch options and validation commands |
| Dashboard Setup | Local dashboard setup, runtime ports, and troubleshooting |
| Deployment | Single-operator production self-host build and serve (loopback-default, not multi-tenant) |
| Deal Configuration | How to customize deal inputs and assumptions |
| Threshold Customization | How to tune underwriting and dealbreaker policy |
| Interpreting Results | How to read generated reports and recommendations |
| Prerequisites | Toolchain and local setup expectations |
| Glossary | CRE and system terminology |
| Troubleshooting | Common issues and recovery procedures |
| Launch Readiness | Release and launch status notes |
| Security Policy | Supported versions and security reporting |
| Contributing | Contribution guidelines |
| Roadmap | Public product and contributor roadmap |
| Changelog | Release history and current-main changes |
If you only want standalone analysis tools for ChatGPT, Codex, Claude Code, Cursor, or another prompt runner, see CRE Agent Skills. It is a separate lightweight repo with individual skill files extracted from this orchestrator.
- CRE firms exploring AI-assisted acquisition workflows
- Proptech developers building CRE tooling
- AI engineers looking for a domain-specific multi-agent reference architecture
- Operators who want a local, inspectable acquisition workflow before trusting automation
This is not an abstract demo. It models the actual diligence, underwriting, financing, legal, and closing workflow that multifamily acquisition teams follow.
Avi Hacker, J.D. - AI Consulting for Commercial Real Estate
Apache 2.0 - Use freely, attribution required. See NOTICE for details.