Inspiration

Property owners, rent regulators and construction lenders pay for building work they never see. A roofer bills for a 52,000 sq ft roof and nobody climbs up to check. A contractor "changes banks" and the payment goes to a scammer. In Los Angeles, tenants can be charged twice for the same renovation. We asked: what if every claim had to match the building itself before anyone paid?

What it does

SiteFolio is an AI agent that checks claims about building work (contractor bills, rent increase requests and construction loan draws) against three independent views of the same building:

  • CoStar: what the building should be (type, size, units, floor plans): 5,245 properties from the kit
  • Vexcel: what the outside really is (roof footprint and shape, rooftop AC units counted in aerial and angled photos)
  • Matterport: what the inside really is (room labels, measured floor areas, a walkable 3D tour)

It then:

  • Blocks fraud: a bill asking to pay a new bank account is stopped at $0.
  • Pays only what's proven: for an overbilled roof it pays for the measured area and holds the rest:

$$\text{pay} = \text{bill} \times \frac{\text{verified area}}{\text{claimed area}}$$

(adjusted for roof slope). A \$312,000 bill for 52,000 sq ft becomes pay \$215,453, hold \$96,547.

  • Releases loan money by proof: a floor plan counts as finished only if its scan shows a kitchen and a bathroom (10 of 13 proven → release \$461,538, hold \$138,462).
  • Catches double rent charges: a landlord's surcharge is denied when the same work is already being charged.
  • Lets a person decide, then records the decision on Solana.

Judges can try it themselves: scan our QR code, write a dishonest bill on your phone, and watch the agent catch it live.

How we built it

  • LangChain Deep Agents (on LangGraph): a coordinator writes a to-do list (write_todos) and changes it mid-run when a check fails. It sends three sub-agents through task (a records clerk for CoStar and bank records, a roof inspector for Vexcel, an interior inspector for Matterport), each with only its own tools. Evidence goes into a per-claim file system (plan.md, one file per data call, findings.md, decision.md), vendor and building notes go into long-term memory (/memories/), and interrupt_on pauses for a human before the decision, then resumes the same run. Every step is traced in LangSmith.
  • AWS Bedrock: Amazon Nova Pro runs the coordinator and Nova Lite runs the inspectors, at about 30 seconds per claim and 9 of 9 decisions correct in our test. Throttling triggers a retry, an unavailable model is skipped, and a per-call fallback goes to free Groq models and then Ollama on a laptop.
  • Safety rails: the AI never does math (plain-code tools compute every amount), plain-code rules overrule the agent if it contradicts them (wrong bank account, active surcharge, amount mismatch), hidden instructions in bills are flagged and ignored, and a person approves every payment.
  • Solana (devnet): one transaction pays the verified amount, locks the disputed amount in a 2-of-2 SPL multisig holding account (lender + SiteFolio), and stamps a sha256 fingerprint of the evidence in a memo. Verify evidence recomputes it, so any later edit turns red. Lenders can sign with Phantom. Owners never touch crypto: the app pays the fees and amounts are in a test dollar token.
  • Tiger Data (TimescaleDB): every event goes into a hypertable with automatic compression, a continuous aggregate keeps weekly paid and held totals for an instant History page, and the agent queries a surcharge registry to catch double charges.
  • Vultr: the whole app runs on a Vultr cloud server with HTTPS (Caddy and Let's Encrypt), a firewall and auto-restart, deployed with one command. That's what makes the phone QR test possible.
  • Stack: React, Vite and Three.js on the frontend; Python and FastAPI on the backend with live updates over server-sent events; tested with 91 backend tests and 40 Playwright click-through tests.

Challenges we ran into

  • Letting AI near money safely. Our first live evaluation got rent decisions wrong, so we added rules that overrule the agent, and kept all math in plain code.
  • Free model rate limits. A deep agent makes about 30 model calls per claim; free tiers stalled for minutes. Bedrock plus a per-call fallback chain fixed it.
  • Never paying twice. A Solana send timed out but had actually landed, so retries now check for an earlier transaction before sending again.
  • Evidence that changes after approval. The agent kept writing files after a person approved, which broke verification, so we seal the evidence folder at approval.
  • Linking three companies' data. We joined CoStar's records to Vexcel by GPS location and to Matterport through CoStar's link table, and flag evidence that's too old to prove new work.

Accomplishments that we're proud of

  • All three CoStar data layers working together on real buildings
  • A deep agent that re-plans on its own and stops for a human
  • A live "try to fool it" test anyone can run from their phone
  • Real Solana transactions with a 2-signature holdback and tamper-proof evidence

What we learned

How to design AI that is useful and safe around money: let the AI investigate and explain, but let code do the math and let people make the final call. We also learned how much more you can trust a number when two independent sources agree.

What's next for SiteFolio

Real USDC payments for construction lenders, more cities' rent rules, live re-scans on demand, and pilots with property managers.

Built With

  • amazon-nova
  • aws-bedrock
  • caddy
  • costar
  • deepagents
  • fastapi
  • groq
  • langchain
  • langgraph
  • langsmith
  • matterport
  • ollama
  • phantom
  • postgresql
  • python
  • react
  • solana
  • spl-token
  • three.js
  • tiger-data
  • timescaledb
  • vexcel
  • vite
  • vultr
Share this project:

Updates

Submission history