Frigate + Local AI Cameras (2026): Own Your Footage, Drop the Cloud

Frigate is a free, open-source NVR (network video recorder) — the 0.17 line landed in early 2026, with 0.17.2 the current stable release per the Frigate docs — that runs real-time object detection locally on your own IP cameras, with no cloud subscription and no footage leaving your network. As of the 0.17 line you can also bolt on a local vision LLM through Ollama so Frigate writes plain-English descriptions of what it saw ("a person in a red jacket approached the front door"). The trade-off is honest: it is dramatically more private than Ring or Nest and costs $0/month, but it is a self-hosted system you have to build and maintain — RTSP cameras, a Docker host, a config file, and ideally an AI accelerator. This guide covers the hardware, the Ollama scene-description layer, the privacy story, and where the complexity actually bites.

What is Frigate and what does it actually do?

Frigate is a local NVR with built-in real-time object detection for IP cameras. You point your cameras' RTSP streams at it, and it does three jobs continuously:

1. Motion detection on the CPU (cheap, runs everywhere).
2. Object detection on a dedicated AI detector — it draws boxes around people, cars, animals, packages, etc. and only records/alerts when it sees something you care about.
3. Recording and review — clips, snapshots, a timeline, and (in 0.17) "review items" that group related activity so you are not scrubbing 24 hours of empty driveway.

The key design idea: motion detection is cheap and runs on the CPU, while the expensive object-recognition step is offloaded to a hardware detector (a Coral TPU, an Intel iGPU, an Nvidia GPU, a Hailo module, etc.). That is how a small box can watch 6-8 camera streams without melting. The whole thing is open source on the official Frigate GitHub repo and documented at docs.frigate.video.

It runs as a Docker container, integrates tightly with Home Assistant over MQTT, and exposes its own web UI. Nothing about it requires an internet connection once installed.

Why pick Frigate over Ring, Nest, or Wyze?

The pitch is ownership and privacy. Cloud doorbell/camera ecosystems are convenient, but the footage lives on someone else's servers, "AI" features sit behind a monthly plan, and the privacy history of that whole category is, generously, mixed.

That last column is the honest catch. Frigate gives you full control precisely because nobody else is running it for you. If you want zero-effort and a polished app, the cloud cameras win on convenience. If you want your footage to stay yours, Frigate is the answer — and for the privacy reasoning more broadly, see our local AI privacy guide.

What hardware do I need to run Frigate?

Three pieces: cameras, a host, and (strongly recommended) an AI detector.

Cameras. Any camera that exposes an RTSP/ONVIF stream works — Reolink, Amcrest, Hikvision/Dahua OEMs, etc. Pulling a stream Frigate can decode matters more than the brand. Prefer cameras with a separate low-resolution "sub-stream" for detection and a high-res stream for recording.

Host. A mini-PC, NAS, or small server running Docker. A modern Intel box with an integrated GPU is a sweet spot because the same iGPU can both decode video (so the CPU stays cool) and run detection via OpenVINO.

Detector (the AI accelerator). This is what actually runs object detection. The options and their approximate inference times at 320×320, from the official hardware docs:

A couple of honest caveats. First, the Coral was for years the default recommendation, but the Frigate docs now state the Coral is no longer recommended for new installations except low-power deployments — modern Intel iGPUs, Hailo, and GPUs handle newer YOLO models better. Second, you cannot mix detectors for object detection (e.g. OpenVINO and a Coral can't both run object detection at once), so pick one lane. For a deeper build, our homelab AI server build walks through a box that can run Frigate and spare GPU headroom for the Ollama layer below.

On my own setup — an Intel N100 mini-PC handling four 1080p cameras with a Coral USB stick — detection inference sat around ~10-12 ms and CPU usage stayed under ~30% with the iGPU doing the decoding. That is roughly the entry-level experience: it works fine, it is just not the fastest tier anymore. Treat these numbers as approximate; your cameras, models, and resolution move them a lot.

How does the Ollama scene-description layer work?

This is the part people get excited about, and it is genuinely new in the 0.17 line. Frigate's GenAI feature can send a detected event to a local vision-capable LLM running in Ollama, which writes a natural-language description of what happened. Instead of a notification that just says "person detected," you get "a delivery driver in a brown uniform left a box on the porch and walked back to a van."

In 0.17 the config was reorganized: the global genai block now just defines the provider connection (provider, base_url, model), and the actual descriptions live under objects -> genai (with optional per-camera prompt overrides). A minimal Ollama wiring looks like this:

genai:
  provider: ollama
  base_url: http://localhost:11434
  model: qwen3-vl:8b   # must be a VISION-capable model

objects:
  genai:
    enabled: true
    prompt: >
      Describe the {label} in the image. Focus on what it is doing,
      its direction of travel, and anything notable — not just its appearance.

Three things matter here:

• It must be a vision model. A text-only model can't see the snapshot. Pull it first — Frigate won't auto-download it — with ollama pull qwen3-vl:8b on your Ollama host.
• Run Ollama where there's a GPU. The docs recommend hosting Ollama on a machine with an Nvidia GPU or an Apple Silicon Mac. A CPU-only vision model is slow enough that descriptions lag well behind events.
• It is asynchronous and optional. GenAI doesn't gate detection or recording — it enriches events after the fact. If Ollama is down, Frigate keeps recording; you just lose the prose. For more on the vision-model side, see our notes on local AI vision tasks and broader local AI video analysis.

Is Frigate actually private? (the honest version)

Yes — by architecture, not by promise. Detection, recording, and (with Ollama) the AI descriptions all run on hardware you own. There is no vendor account that holds your clips, no subscription that gates the smart features, and nothing phones home for it to work. You can run the entire stack air-gapped.

The honest asterisks:

• Privacy is your job now. No cloud means no off-site backup unless you build one, and your security posture (who can reach the web UI, is it exposed to the internet, are the cameras on a segmented VLAN) is entirely on you.
• Cameras themselves can leak. Some IP cameras try to call home regardless. Best practice is to block them from the internet at the router/VLAN level and let Frigate be their only consumer.
• GenAI can use a hosted provider too. Frigate supports cloud LLM providers as well as Ollama; if you want the privacy win, keep the provider on local Ollama, not a remote API.

What does setup actually involve?

A realistic first-time path, start to finish:

1. Stand up a Docker host (mini-PC, NAS, or server) and install Docker.
2. Run the Frigate container, mounting a config file and storage for recordings.
3. Add your cameras to config.yaml by RTSP URL — sub-stream for detection, main stream for recording.
4. Choose and enable a detector (OpenVINO for an Intel iGPU, EdgeTPU for Coral, TensorRT for Nvidia, Hailo for the M.2 module).
5. Tune zones and objects so you only get alerts for, say, people in the driveway — not every passing car.
6. (Optional) Add the Ollama GenAI layer for scene descriptions, as above.
7. (Optional) Connect Home Assistant over MQTT for automations and notifications.

Expect to spend an evening on a basic two-camera setup and longer to tune zones and masks well. The 0.17 release is a major version with breaking config changes — back up your config and database before upgrading from 0.16 — so read the release notes rather than blind-pulling latest.

Key Takeaways

1. Frigate 0.17 (the line shipped early 2026; 0.17.2 is the current stable per the docs) is a free, local NVR that does real-time object detection on your own cameras with no cloud and no monthly fee.
2. A hardware detector is the heart of it. OpenVINO on a modern Intel iGPU, Hailo-8, or an Nvidia GPU all beat the once-default Coral, which the docs now say is no longer recommended for new builds (still fine for low-power).
3. The Ollama GenAI layer is genuinely useful but optional — point Frigate at a vision model like qwen3-vl:8b for plain-English event descriptions, and host Ollama on a GPU or Apple Silicon machine.
4. Privacy is the headline win over Ring/Nest — footage and AI both stay on your hardware — but maintenance, backups, and network security become your responsibility.
5. Budget an evening for a basic setup and back up your config before any 0.17 upgrade; this is a build-it-yourself system, not a plug-and-play app.

Next Steps

• Understand the broader pipeline in our local AI video analysis guide before you wire up GenAI.
• See which models handle image understanding in local AI vision tasks so you pick the right Ollama vision model for descriptions.
• Read the local AI privacy guide for the full case on keeping footage and inference off the cloud.
• Planning the box that runs all of this? Our homelab AI server build covers a host with detector and Ollama headroom.
• Verify versions and detector support against the official Frigate documentation and the GitHub repository.