Mechus
Your AI Property Inspector. Just Answer the Call.
Inspiration
Move-in and move-out inspections are where landlords and tenants often stop trusting each other.
One side brings a clipboard. The other brings a handful of blurry photos. Months later, a security deposit can depend on whose memory wins.
We wanted to build an inspection process that neither side has to take on faith: one that evaluates the actual condition of a property, captures evidence in real time, and creates a transparent record both parties can access.
We also didn't want another app to install. Almost everyone with an iPhone already knows how to answer a FaceTime call, so we made that our primary interface.
The result is Mechus: an AI property inspector you can FaceTime.
What It Does
Mechus joins a FaceTime-style video walkthrough and acts as an intelligent, real-time property inspector.
- Live AI Walkthroughs
A tenant answers a video call and walks through their unit. Mechus continuously analyzes the camera feed, identifies potential damage, and speaks naturally when it notices something worth investigating.
If something is unclear, it asks for another look:
"Can you show me that wall again?"
"Could you move the camera a little closer?"
"Okay, everything looks good there."
Rather than simply recording footage, Mechus actively participates in the inspection.
- Move-In vs. Move-Out Comparisons
During the initial move-in inspection, Mechus saves video frames and establishes a baseline of the property's condition.
During move-out, the live camera feed is compared against that baseline. Instead of flagging every imperfection, Mechus focuses on identifying changes and potential new damage.
- Automated Landlord Dashboard
Uploaded walkthrough footage is transformed into a structured property condition report featuring:
Before-and-after images for individual findings.
Room-by-room condition summaries.
Potential damage classifications and severity ratings.
Estimated repair costs.
Tenant acknowledgment and dispute functionality.
- Shared Property History
Mechus integrates with an iMessage group to maintain a shared timeline of property-related communication, including repairs, photos, and agreements.
The goal is simple: both parties should have access to the same record.
How We Built It
Real-Time Video Infrastructure
Mechus joins a LiveKit room as an independent participant, publishing its own audio track and video tile.
The caller connects to the same room, routing their camera and microphone through standard LiveKit streams.
A dedicated Python worker process handles each individual call, allowing inspections to run independently.
Vision and Perception
Every three seconds, Mechus captures the newest camera frame and sends it to Gemini Flash-Lite.
The model returns structured information about the scene, including:
Objects and surfaces in view.
Visibility and image clarity.
Bounding boxes.
Potential damage and severity ratings.
A suggested spoken response.
We selected Flash-Lite for its low inference latency, approximately one second per frame in our testing, making it suitable for an interactive walkthrough.
Speech and Audio
Mechus uses real-time speech-to-text and text-to-speech pipelines to communicate with tenants.
The system can interpret spoken responses and generate conversational audio, allowing the inspection to feel more like a guided conversation than an automated recording.
Memory and Storage
Move-in baselines, inspection histories, and findings are persisted in MongoDB, with a local-file fallback.
This allows Mechus to retrieve historical inspection data and compare it against subsequent walkthroughs.
Automated Reporting
The dashboard processes uploaded videos using FFmpeg to extract representative frames.
Vision models then identify rooms, evaluate property conditions, and compare move-out footage against the original move-in baseline.
The resulting findings are organized into a condition report with supporting visual evidence and estimated repair costs.
Backend Architecture
The backend is built with Python and Flask.
The API server manages inspection sessions, launches dedicated worker processes, coordinates the live agent, and serves the landlord dashboard.
Keeping Mechus from Chattering
One of our biggest engineering challenges was making Mechus sound like an actual inspector rather than a model narrating every frame.
At one frame every three seconds, the agent receives a continuous stream of visual information. Without additional logic, it would repeatedly announce the same observations.
We implemented a similarity-based filtering system using word stemming and Jaccard similarity:
[ J(A,B)=\frac{|A\cap B|}{|A\cup B|} ]
Each new observation is compared against previously announced findings. If its similarity score is above 0.5, it is treated as a repetition rather than a new finding.
The same approach helps determine whether the camera has transitioned to a different area or whether the agent is simply rephrasing an earlier question.
We also implemented an all-clear verification system. Mechus only signs off on an area after observing multiple consecutive, damage-free frames of that same location.
This prevents a quick camera movement or passing glance from being mistaken for a completed inspection.
Our philosophy: Let the model decide what could be said, but let code decide whether it should be said.
Challenges We Ran Into
- One await Broke Every Video Call
The LiveKit Python SDK handles audio and video frame publishing differently.
Publishing an audio frame is synchronous, while publishing a video track involves asynchronous operations. We initially awaited a video operation incorrectly, triggering a TypeError during connection and crashing the call before it could begin.
Our standard mock tests passed without issues. Only testing against an actual video stream exposed the integration bug.
This reinforced the importance of testing real-time systems against real streams early in development.
- Handling API Rate Limits
At one frame every three seconds, our expected request volume was:
[ \frac{60}{3}=20 \text{ requests per minute} ]
Our initial live tests began encountering API rate limits around the 45-second mark.
We implemented exponential backoff to handle rate-limit responses gracefully, allowing the agent to wait and resume instead of repeatedly overwhelming the API.
- Teaching Speech Recognition a Made-Up Name
"Mechus" isn't a standard dictionary word.
Our transcription pipeline initially interpreted the name as "mech is."
We addressed this by biasing the recognizer toward our custom name, whitelisting common transcription errors, and implementing logic to rejoin split forms.
We also added safeguards to prevent ordinary words like "mechanic" from accidentally activating the agent.
- Sounding Like an Inspector, Not a Narrator
Having a vision model comment on every frame quickly becomes overwhelming.
We separated visual intelligence from conversational pacing.
The model identifies what might be worth saying, while our application code enforces:
Structural findings take priority.
A maximum of two questions per location.
Repeated observations are suppressed.
Previously answered questions aren't asked again.
Quiet periods are intentionally maintained.
Timing turned out to be just as important as perception.
- Two Branches, One Product
The live-call agent and landlord dashboard were developed in parallel by different contributors.
Initially, clicking the dashboard's FaceTime button placed a call into an empty LiveKit room.
The two systems had different assumptions about how inspection sessions were created and routed.
We resolved this by updating the routing logic so the dashboard dynamically connects directly to the appropriate live worker process.
What We Learned
Test against real hardware early. Mock tests can hide asynchronous integration bugs that only appear with actual video streams.
Timing is a feature. In real-time voice applications, knowing when to remain silent matters just as much as knowing what to say.
Separate intelligence from execution. Let the model determine what is relevant, but use deterministic application logic to control when actions happen.
Small, fast models matter. When someone is physically standing in a room waiting for an answer, inference latency directly affects the user experience.
Integration is its own engineering challenge. Building individual components is only half the work; getting them to function as one cohesive product is equally important.
What's Next
Automated Inspection Wrap-Up
Feed live-call findings directly into the final report, allowing Mechus to conclude walkthroughs with an automated summary and notifications such as:
"Tenant Joey completed his check-out inspection!"
Guided Inspection Checklists
Introduce dynamic, room-by-room checklists that track which areas and property features have been inspected.
Mechus will actively prompt tenants to show anything that hasn't yet been captured on camera.
Human-in-the-Loop Safeguards
AI-generated findings should never independently determine financial penalties.
We plan to maintain mandatory human review before landlords can finalize charges or security deposit deductions. Tenants will retain the ability to acknowledge or dispute individual findings.
Mechus is ultimately about making property inspections transparent, consistent, and accessible to everyone involved.
No clipboard. No arguing over blurry photos. Just answer the call.
