This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend
I built HomeWatch, a local-first AI assistant that helps my friend keep an eye on their home and, more specifically, their dog while they're away.
The problem was simple: they have a camera pointed at the main living area, but checking through hours of footage to figure out what happened during the day is tedious. They would often end up opening the camera app repeatedly just to answer questions like:
“What did the dog do while I was out?”
HomeWatch processes the camera footage locally and turns it into a simple timeline of what happened.
Instead of watching hours of video, they can ask questions such as:
The system detects and summarises relevant events, allowing them to quickly understand what happened without manually reviewing the entire recording.
It can also highlight potentially unusual behaviour, such as the dog spending an unusually long amount of time waiting by the front door.
Most importantly, the camera footage stays in the home. It isn't uploaded to a commercial AI service just to answer a question about what happened in someone's living room.
Live demo: https://homewatch.com
Demo video: https://www.youtube.com/watch?v=qEBLVw2QVHX
The demo shows a sample recording being processed into an event timeline, followed by natural-language questions about the events detected in the footage.
GitHub: https://github.com/tba/homewatch
HomeWatch is fully open source and can be run locally.
HomeWatch is built around open-weight AI models running locally.
The application combines computer vision, video processing, local embeddings, and a local language model.
The basic pipeline looks like this:
Camera
│
▼
Video Stream
│
▼
Frame / Event Detection
│
├── Person detection
├── Animal detection
├── Object detection
└── Scene changes
│
▼
Event Extraction
│
▼
Local Vision Model
│
▼
Event Database
│
▼
Local LLM + RAG
│
▼
Natural-language answers
The camera stream is processed locally. Relevant events are extracted rather than requiring the entire video history to be sent to an external service.
The events are stored with timestamps and contextual information, allowing the language model to retrieve the relevant events when a question is asked.
For example, a question such as:
"What did Luna do between 2pm and 4pm?"
can be answered from the locally generated event history rather than asking the model to analyse two hours of video every time.
The AI model is also replaceable. Users can select different open-weight models depending on their available hardware, allowing the system to run on anything from a reasonably powerful desktop to a dedicated home server.
Home camera footage is some of the most private data a person can generate.
Sending that footage to a third-party AI service would mean trusting another company with video from inside someone's home, potentially including family members, visitors, children, pets, conversations, and other sensitive information.
Using open models running locally changes that equation.
Privacy: The camera footage never needs to leave the home.
Offline operation: Once the models are installed, the system can continue working without an internet connection.
No per-video API costs: Processing can happen locally without paying an external provider for every frame or request.
Model choice: Different models can be tested and swapped without rebuilding the entire application around one proprietary API.
Control: The detection, retrieval, prompting, and model layers are all accessible and configurable.
The open approach also makes the project more useful as a home-lab application. Someone can run it on their own server, experiment with different models, and adapt the behaviour to their particular cameras, pets, or household.
The project was developed with an AI coding agent, using the agent to help design the event-processing pipeline, implement the local inference workflow, and build the natural-language query interface.
DevRelay session: https://devrelay.tba.com/sessions/homewatch
The session shows the development process from the initial idea through to the working prototype.