AI Agents for Real Estate: Property Search, Mortgage Calculators, and Viewing Automation

Why Real Estate Is Ripe for AI Agents

Real estate transactions involve massive information asymmetry. Buyers spend an average of 10 weeks searching for a property, visiting 8-12 homes, and making 2-3 offers before closing. Agents spend 60% of their time on administrative tasks — scheduling viewings, answering repetitive questions about properties, and qualifying leads — rather than the high-value advisory work that justifies their commission.

AI agents can compress the search-to-viewing pipeline from weeks to days by understanding buyer preferences through natural conversation, searching across multiple listing databases simultaneously, running financial calculations in real time, and automating the scheduling of property viewings.

Multi-Agent Property Search Architecture

A real estate AI system works best as a multi-agent setup where specialized agents handle different aspects of the property search workflow.

from dataclasses import dataclass, field
from typing import Optional
from enum import Enum

class PropertyType(Enum):
    HOUSE = "house"
    APARTMENT = "apartment"
    TOWNHOUSE = "townhouse"
    LAND = "land"
    COMMERCIAL = "commercial"

@dataclass
class BuyerPreferences:
    budget_min: float
    budget_max: float
    property_types: list[PropertyType]
    bedrooms_min: int = 0
    bathrooms_min: int = 0
    locations: list[str] = field(default_factory=list)
    must_have: list[str] = field(default_factory=list)  # "garage", "pool"
    nice_to_have: list[str] = field(default_factory=list)
    deal_breakers: list[str] = field(default_factory=list)
    investment_purpose: bool = False
    max_commute_minutes: Optional[int] = None
    commute_destination: Optional[str] = None

@dataclass
class PropertyListing:
    id: str
    address: str
    suburb: str
    city: str
    price: float
    property_type: PropertyType
    bedrooms: int
    bathrooms: int
    area_sqm: float
    features: list[str]
    description: str
    images: list[str]
    days_on_market: int
    price_history: list[dict]
    agent_name: str
    agent_phone: str

class PropertySearchAgent:
    """Searches across multiple listing sources and ranks results
    against buyer preferences."""

    def __init__(self, listing_sources: list, llm_client, geocoder):
        self.sources = listing_sources
        self.llm = llm_client
        self.geocoder = geocoder

    async def search(
        self, prefs: BuyerPreferences
    ) -> list[dict]:
        import asyncio

        # Search all listing sources in parallel
        tasks = [
            source.search(
                price_min=prefs.budget_min,
                price_max=prefs.budget_max,
                property_types=[
                    pt.value for pt in prefs.property_types
                ],
                bedrooms_min=prefs.bedrooms_min,
                bathrooms_min=prefs.bathrooms_min,
                locations=prefs.locations,
            )
            for source in self.sources
        ]
        results = await asyncio.gather(*tasks)

        # Deduplicate across sources
        all_listings = self._deduplicate(
            [l for source_results in results for l in source_results]
        )

        # Filter deal-breakers
        filtered = [
            l for l in all_listings
            if not self._has_deal_breaker(l, prefs.deal_breakers)
        ]

        # Score and rank
        scored = []
        for listing in filtered:
            score = await self._score_listing(listing, prefs)
            scored.append({"listing": listing, "score": score})

        scored.sort(key=lambda x: x["score"]["total"], reverse=True)
        return scored[:20]

    async def _score_listing(
        self, listing: PropertyListing, prefs: BuyerPreferences
    ) -> dict:
        scores = {}

        # Price score: prefer listings in the lower-middle of budget
        budget_mid = (prefs.budget_min + prefs.budget_max) / 2
        price_ratio = listing.price / budget_mid
        scores["price"] = max(0, 100 - abs(1 - price_ratio) * 100)

        # Feature match score
        must_have_matches = sum(
            1 for f in prefs.must_have
            if f.lower() in " ".join(listing.features).lower()
        )
        scores["must_have"] = (
            (must_have_matches / len(prefs.must_have) * 100)
            if prefs.must_have else 100
        )

        nice_matches = sum(
            1 for f in prefs.nice_to_have
            if f.lower() in " ".join(listing.features).lower()
        )
        scores["nice_to_have"] = (
            (nice_matches / len(prefs.nice_to_have) * 50)
            if prefs.nice_to_have else 50
        )

        # Commute score
        if prefs.max_commute_minutes and prefs.commute_destination:
            commute = await self.geocoder.driving_time(
                listing.address, prefs.commute_destination
            )
            if commute <= prefs.max_commute_minutes:
                scores["commute"] = 100
            else:
                overage = commute - prefs.max_commute_minutes
                scores["commute"] = max(0, 100 - overage * 5)
        else:
            scores["commute"] = 50

        # Days on market: fresh listings score higher
        scores["freshness"] = max(0, 100 - listing.days_on_market * 2)

        scores["total"] = (
            scores["price"] * 0.25
            + scores["must_have"] * 0.30
            + scores["nice_to_have"] * 0.10
            + scores["commute"] * 0.20
            + scores["freshness"] * 0.15
        )
        return scores

    def _has_deal_breaker(
        self, listing: PropertyListing, deal_breakers: list[str]
    ) -> bool:
        listing_text = (
            listing.description + " " + " ".join(listing.features)
        ).lower()
        for db in deal_breakers:
            if db.lower() in listing_text:
                return True
        return False

    def _deduplicate(
        self, listings: list[PropertyListing]
    ) -> list[PropertyListing]:
        seen_addresses = set()
        unique = []
        for l in listings:
            key = l.address.lower().strip()
            if key not in seen_addresses:
                seen_addresses.add(key)
                unique.append(l)
        return unique

Suburb Intelligence Agent

One of the most valuable features of a real estate AI agent is suburb intelligence — providing detailed, data-driven insights about neighborhoods that go far beyond what a listing description offers.

@dataclass
class SuburbProfile:
    name: str
    median_price: float
    price_growth_1y: float
    price_growth_5y: float
    rental_yield: float
    school_rating: float
    crime_rate: float  # per 1000 residents
    walkability_score: int  # 0-100
    transit_score: int  # 0-100
    demographics: dict
    amenities: dict  # {"restaurants": 45, "parks": 12, ...}

class SuburbIntelligenceAgent:
    def __init__(self, data_sources: dict, llm_client):
        self.data = data_sources
        self.llm = llm_client

    async def analyze(self, suburb: str, city: str) -> SuburbProfile:
        import asyncio

        tasks = {
            "pricing": self.data["property"].get_suburb_stats(
                suburb, city
            ),
            "schools": self.data["education"].get_school_ratings(
                suburb, city
            ),
            "crime": self.data["safety"].get_crime_stats(suburb, city),
            "walkability": self.data["transport"].get_walkability(
                suburb, city
            ),
            "demographics": self.data["census"].get_demographics(
                suburb, city
            ),
            "amenities": self.data["places"].get_amenity_counts(
                suburb, city
            ),
        }

        results = {}
        for key, coro in tasks.items():
            results[key] = await coro

        return SuburbProfile(
            name=suburb,
            median_price=results["pricing"]["median"],
            price_growth_1y=results["pricing"]["growth_1y"],
            price_growth_5y=results["pricing"]["growth_5y"],
            rental_yield=results["pricing"]["rental_yield"],
            school_rating=results["schools"]["avg_rating"],
            crime_rate=results["crime"]["rate_per_1000"],
            walkability_score=results["walkability"]["walk_score"],
            transit_score=results["walkability"]["transit_score"],
            demographics=results["demographics"],
            amenities=results["amenities"],
        )

    async def compare_suburbs(
        self, suburbs: list[str], city: str, buyer_priorities: list[str]
    ) -> str:
        profiles = [
            await self.analyze(s, city) for s in suburbs
        ]

        comparison_prompt = (
            f"Compare these suburbs for a buyer who prioritizes "
            f"{', '.join(buyer_priorities)}:\n\n"
        )
        for p in profiles:
            comparison_prompt += (
                f"**{p.name}**: Median ${p.median_price:,.0f}, "
                f"growth {p.price_growth_1y:.1f}%, "
                f"rental yield {p.rental_yield:.1f}%, "
                f"schools {p.school_rating}/10, "
                f"crime {p.crime_rate}/1000, "
                f"walk score {p.walkability_score}\n"
            )

        response = await self.llm.chat(messages=[{
            "role": "user",
            "content": comparison_prompt,
        }])
        return response.content

Mortgage and Investment Calculator Agent

Real estate AI agents become dramatically more useful when they can run financial calculations in real time during the conversation.

@dataclass
class MortgageCalculation:
    loan_amount: float
    interest_rate: float
    term_years: int
    monthly_payment: float
    total_interest: float
    total_cost: float

@dataclass
class InvestmentAnalysis:
    purchase_price: float
    estimated_rent_weekly: float
    annual_rental_income: float
    annual_expenses: float
    net_rental_yield: float
    cash_flow_monthly: float
    projected_value_5y: float
    projected_value_10y: float
    total_return_10y: float

class FinancialCalculatorAgent:
    def calculate_mortgage(
        self,
        property_price: float,
        deposit_percent: float,
        interest_rate: float,
        term_years: int = 30,
    ) -> MortgageCalculation:
        deposit = property_price * (deposit_percent / 100)
        loan_amount = property_price - deposit
        monthly_rate = interest_rate / 100 / 12
        n_payments = term_years * 12

        if monthly_rate == 0:
            monthly_payment = loan_amount / n_payments
        else:
            monthly_payment = loan_amount * (
                monthly_rate * (1 + monthly_rate) ** n_payments
            ) / ((1 + monthly_rate) ** n_payments - 1)

        total_cost = monthly_payment * n_payments
        total_interest = total_cost - loan_amount

        return MortgageCalculation(
            loan_amount=round(loan_amount, 2),
            interest_rate=interest_rate,
            term_years=term_years,
            monthly_payment=round(monthly_payment, 2),
            total_interest=round(total_interest, 2),
            total_cost=round(total_cost, 2),
        )

    def analyze_investment(
        self,
        purchase_price: float,
        estimated_rent_weekly: float,
        annual_growth_rate: float = 3.0,
        vacancy_rate: float = 5.0,
        management_fee_pct: float = 8.0,
        annual_maintenance: float = 3000.0,
        insurance_annual: float = 1500.0,
        council_rates_annual: float = 2000.0,
    ) -> InvestmentAnalysis:
        gross_annual_rent = estimated_rent_weekly * 52
        vacancy_loss = gross_annual_rent * (vacancy_rate / 100)
        effective_rent = gross_annual_rent - vacancy_loss
        management_fee = effective_rent * (management_fee_pct / 100)

        annual_expenses = (
            management_fee
            + annual_maintenance
            + insurance_annual
            + council_rates_annual
        )
        net_income = effective_rent - annual_expenses
        net_yield = (net_income / purchase_price) * 100
        cash_flow_monthly = net_income / 12

        growth_rate = annual_growth_rate / 100
        projected_5y = purchase_price * (1 + growth_rate) ** 5
        projected_10y = purchase_price * (1 + growth_rate) ** 10
        total_return = (
            (projected_10y - purchase_price) + (net_income * 10)
        )

        return InvestmentAnalysis(
            purchase_price=purchase_price,
            estimated_rent_weekly=estimated_rent_weekly,
            annual_rental_income=round(effective_rent, 2),
            annual_expenses=round(annual_expenses, 2),
            net_rental_yield=round(net_yield, 2),
            cash_flow_monthly=round(cash_flow_monthly, 2),
            projected_value_5y=round(projected_5y, 2),
            projected_value_10y=round(projected_10y, 2),
            total_return_10y=round(total_return, 2),
        )

Automated Viewing Scheduling

Once a buyer identifies properties they want to see, the AI agent can coordinate with listing agents to schedule viewings efficiently, grouping nearby properties into a single trip.

from datetime import datetime, timedelta

class ViewingSchedulerAgent:
    def __init__(self, geocoder, calendar_client, llm_client):
        self.geocoder = geocoder
        self.calendar = calendar_client
        self.llm = llm_client

    async def schedule_viewing_route(
        self,
        properties: list[PropertyListing],
        buyer_available_slots: list[dict],
        start_location: str,
    ) -> list[dict]:
        # Step 1: Geocode all properties
        coords = {}
        for p in properties:
            coords[p.id] = await self.geocoder.geocode(p.address)

        # Step 2: Optimize viewing order (nearest-neighbor TSP)
        ordered = self._optimize_route(
            properties, coords, start_location
        )

        # Step 3: Assign time slots (30 min per viewing + travel)
        schedule = []
        current_time = None

        for slot in buyer_available_slots:
            current_time = datetime.fromisoformat(slot["start"])
            slot_end = datetime.fromisoformat(slot["end"])

            for prop in ordered:
                if current_time + timedelta(minutes=45) > slot_end:
                    break  # no more time in this slot

                schedule.append({
                    "property": prop,
                    "viewing_time": current_time.isoformat(),
                    "duration_minutes": 30,
                    "travel_to_next_minutes": 15,
                })
                current_time += timedelta(minutes=45)
                ordered.remove(prop)

        return schedule

    def _optimize_route(
        self,
        properties: list,
        coords: dict,
        start: str,
    ) -> list:
        # Simple nearest-neighbor heuristic
        remaining = list(properties)
        ordered = []
        current = start

        while remaining:
            nearest = min(
                remaining,
                key=lambda p: self._distance(
                    coords.get(current, (0, 0)),
                    coords[p.id],
                ),
            )
            ordered.append(nearest)
            current = nearest.id
            remaining.remove(nearest)

        return ordered

    def _distance(self, a: tuple, b: tuple) -> float:
        return ((a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2) ** 0.5

FAQ

How does a real estate AI agent handle properties that are not yet on major listing platforms?

The best real estate AI agents integrate with multiple data sources: MLS feeds, off-market databases, builder pre-release lists, and even social media monitoring for "coming soon" posts. The multi-source search architecture described above supports adding new listing sources as simple adapter implementations. For truly off-market properties, the agent can alert buyers when a property matching their criteria appears in any connected data source.

Can an AI agent replace a real estate agent?

Not entirely. AI agents excel at the information-heavy, repetitive parts of real estate: searching, filtering, calculating, and scheduling. Human agents provide relationship management, negotiation strategy, local market intuition, and legal guidance. The most effective model is an AI agent that handles 80% of the grunt work, freeing the human agent to focus on high-value advisory and negotiation.

How accurate are AI-generated suburb intelligence reports?

The accuracy depends entirely on the data sources. When connected to official government databases (census data, crime statistics, school ratings), the factual data is highly accurate. Market predictions (price growth, yield estimates) are based on historical trends and should always include confidence intervals and disclaimers. The AI agent adds value by synthesizing data from multiple sources into a coherent narrative, not by making predictions beyond what the data supports.

What about privacy concerns with location tracking for commute calculations?

Commute calculations use the buyer's stated workplace address, not real-time tracking. The address is used only for point-to-point routing calculations and can be stored as a geocoded coordinate rather than a full address. Buyers should be informed about what data is collected and given the option to skip commute-based ranking. All location data should be encrypted and deleted when the search session ends.

---

#RealEstateAI #PropertySearch #MortgageCalculator #AIAgents #PropTech #SuburbIntelligence