Skip to content

Frigate + Home Assistant Optimization Report

Date: 2026-02-24 Context: Frigate 0.16.4 on Docker VM (Proxmox VM 101, Intel N150), 3 cameras, Home Assistant with MQTT integration, ntfy notifications.

Part 1: Reducing Notification Noise

Problem

Current automations trigger on every person detection across the full camera frame. Family members entering/exiting home generate constant notifications. Goal: alert for unknown persons and security events, suppress known family activity.

Strategy 1: Frigate Zones + required_zones (Highest Impact)

Zones restrict where in the camera frame a detection must occur before triggering an event. Key settings:

  • inertia: 3 -- object must be in zone for 3 consecutive frames (filters bounding box jitter)
  • loitering_time: 4 -- object must stay 4+ seconds (filters passersby on the street)
  • required_zones on review.alerts -- Frigate only creates reviewable events for those zones

Example for front_door camera:

cameras:
  front_door:
    zones:
      porch:
        coordinates: 0.2,0.6,0.8,0.6,0.8,1.0,0.2,1.0
        objects:
          - person
        inertia: 3
        loitering_time: 4
      driveway:
        coordinates: ...
        objects:
          - person
          - car
    review:
      alerts:
        labels:
          - person
        required_zones:
          - porch
      detections:
        labels:
          - person
          - car
        required_zones:
          - driveway

Zone coordinates are defined via Frigate's web UI zone editor. The bottom center of the bounding box determines zone presence.

Strategy 2: Frigate Native Face Recognition (Built into 0.16+)

Frigate 0.16 added built-in face recognition. When a person is detected, Frigate runs face detection on the person crop and assigns a sub_label (e.g., "augusto") if the face matches a trained individual. No external tools needed.

Configuration:

face_recognition:
  enabled: true
  model_size: small          # "small" for CPU, "large" for GPU
  detection_threshold: 0.7
  recognition_threshold: 0.9
  unknown_score: 0.8
  min_faces: 1
  min_area: 500
  save_attempts: 100
  blur_confidence_filter: true

Training:

  • Start with 10-30 front-facing photos per person via Frigate's "Train" tab
  • Build to 50-100 for optimal accuracy
  • Avoid hats, sunglasses, extreme angles, IR images
  • Face database lives at /media/frigate/clips/faces

Sub-labels in MQTT events: "sub_label": ["augusto", 0.92]

Automation filtering:

# Only notify for UNKNOWN persons
condition:
  - condition: template
    value_template: >-
      {{ trigger.payload_json["after"]["sub_label"] is none or
         trigger.payload_json["after"]["sub_label"][0] not in
         ["augusto", "andre"] }}

Timing gotcha: Face recognition takes a few seconds after initial person detection. The first MQTT event will have sub_label: null. Sub-labels arrive in subsequent update events. Automations should use a repeat-wait loop or process update events.

Strategy 3: SgtBatten Blueprint (Community Gold Standard)

The SgtBatten Frigate Camera Notifications Blueprint is the most widely used notification automation. It handles:

  • Zone filtering with required zones
  • Cooldown timer per camera (prevents spam)
  • Silence/snooze timer (manual suppression)
  • Presence-based suppression (disable when family is home)
  • Time-based restrictions (different behavior day vs night)
  • Sub-label support (recognized face name in notification)
  • Rich media (thumbnails, snapshots, GIFs, video clips with bounding boxes)
  • Actionable notification buttons (snooze, view clip, dismiss)
  • Multi-device support (Android, iOS)

Install via HACS or import from the GitHub repo. Creates one automation per camera.

Strategy 4: Presence-Based Suppression

Use HA Companion App (phone GPS) to track person.augusto and person.andre. Suppress outdoor camera notifications when family is home.

# Suppress when anyone is home
condition:
  - condition: state
    entity_id: group.family
    state: "not_home"

Key: suppress notifications only, not recordings. Recordings should always run for security.

Frigate also exposes MQTT topics for per-camera notification control:

  • frigate/<camera>/notifications/set -- ON/OFF
  • frigate/<camera>/notifications/suspend -- minutes to suspend

Strategy 5: Time-Based Rules

# Sun-based (better than fixed times)
condition:
  - condition: sun
    after: sunset
    after_offset: "-01:00:00"
    before: sunrise
    before_offset: "00:30:00"

Community patterns:

  • Night: Notify on ALL person detections, use critical/high-priority alerts that break through DND
  • Day: Only notify for persons in required zones (porch, front door)
  • Away: All cameras, all zones, all alerts regardless of time

Strategy 6: Cooldown / Rate Limiting

Manual cooldown via last_triggered:

condition:
  - condition: template
    value_template: >-
      {{ not state_attr('automation.frigate_front_door', 'last_triggered') or
         (now() - state_attr('automation.frigate_front_door', 'last_triggered') >
         timedelta(minutes=3)) }}

The SgtBatten blueprint has this built-in with a configurable cooldown parameter.

What NOT to Use

Tool Status Recommendation
Double-Take (original) Last commit Feb 2024, abandoned Skip
Double-Take (skrashevich fork) Community fork, somewhat active Only if native doesn't work
CompreFace HA add-on broken after Core 2025 Avoid
DeepStack No longer available Dead
LLM-based filtering Promising but unreliable per Frigate devs Wait for Frigate 0.17
  1. Zones + required_zones -- highest impact, no new software
  2. Face recognition -- enable in frigate.yml, train family faces
  3. SgtBatten blueprint -- replace custom YAML automations
  4. Presence suppression -- after Companion App is installed
  5. Time-based rules -- via blueprint or custom conditions
  6. Cooldown tuning -- 3-5 min per camera

Part 2: Hardware Acceleration (OpenVINO + VAAPI)

Problem

Frigate reports "CPU is Slow" because it's using the default TFLite CPU detector (~100 ms inference). The Intel N150 has an integrated GPU that's sitting idle.

Intel N150 Capabilities

Spec Value
CPU 4 E-cores (Gracemont), 3.6 GHz boost
iGPU Intel UHD Graphics, 24 EUs, Xe-LP architecture
TDP 6W base
OpenVINO Fully supported (CPU + GPU inference)
VAAPI/QuickSync Fully supported (H.264/H.265 decode)

Change 1: Switch to OpenVINO GPU Detector (High Impact)

The standard ghcr.io/blakeblackshear/frigate:stable image already includes OpenVINO and the default SSDLite MobileNet v2 model. No image change needed.

Current config

detectors:
  cpu:
    type: cpu
    num_threads: 2

detectors:
  ov:
    type: openvino
    device: GPU

model:
  width: 300
  height: 300
  input_tensor: nhwc
  input_pixel_format: bgr
  path: /openvino-model/ssdlite_mobilenet_v2.xml
  labelmap_path: /openvino-model/coco_91cl_bkgr.txt

Expected improvement:

Config Inference Speed
CPU TFLite (current) ~100 ms
OpenVINO GPU, MobileNet v2 ~15 ms
OpenVINO GPU, YOLO-NAS-S ~25-30 ms
Coral USB TPU (comparison) ~10 ms

At 15 ms inference, capacity is ~66 detections/second. With 3 cameras at 2 fps detect = 6 frames/second needed. That's 10x headroom.

Important: Do NOT use device: AUTO -- there is a known bug. Explicitly set GPU or CPU.

Change 2: Enable VAAPI Hardware Video Decoding (High Impact)

The Docker Compose already passes /dev/dri:/dev/dri, but VAAPI is commented out in the Frigate config. Enabling it offloads H.264/H.265 decoding from CPU to iGPU.

Current config (commented out)

# ffmpeg:
#   hwaccel_args: preset-vaapi

ffmpeg:
  hwaccel_args: preset-vaapi

VAAPI is preferred over QSV for the N150 because it auto-detects the codec (H.264 vs H.265). QSV requires codec-specific presets per camera.

Verify after enabling:

docker exec frigate vainfo
# Should show VAProfileH264High : VAEntrypointVLD

Change 3: Drop the Coral USB TPU Plan

The Google Coral USB Accelerator is discontinued and no longer recommended by Frigate. OpenVINO on the N150's iGPU matches or approaches Coral performance (~15 ms vs ~10 ms) without any additional hardware.

GPU Resource Sharing

Both VAAPI decoding and OpenVINO inference share the N150's 24 EU iGPU. With 3 cameras at 2 fps detect, this is well within capacity. Monitor with:

docker exec frigate intel_gpu_top  # may need CAP_PERFMON

If running many more cameras, consider adding CAP_PERFMON to Docker Compose:

cap_add:
  - CAP_PERFMON

Optional: YOLO-NAS-S Model (Better Accuracy)

For improved detection accuracy (especially for small/distant objects), YOLO-NAS-S can replace MobileNet v2 at the cost of ~25-30 ms inference (still fast enough):

detectors:
  ov:
    type: openvino
    device: GPU

model:
  width: 320
  height: 320
  input_tensor: nchw
  input_pixel_format: bgr
  model_type: yolonas
  path: /config/model_cache/yolo_nas_s.onnx

Requires exporting the model via Python super_gradients package. Consider this if MobileNet v2 produces too many false positives/negatives.

Net Effect

With OpenVINO GPU + VAAPI enabled, the heaviest workloads (video decoding + object detection) run on the iGPU, freeing the 4 CPU cores for motion detection, recording, go2rtc, and other Docker containers on the VM.

Workload Before After
Object detection CPU (~100 ms) iGPU (~15 ms)
Video decoding CPU (ffmpeg software) iGPU (VAAPI hardware)
Motion detection CPU CPU (unchanged)
Recording/encoding CPU CPU (unchanged)

Summary: Priority Actions

Priority Action Impact
1 Enable OpenVINO GPU detector Inference 100 ms -> 15 ms
2 Enable VAAPI hardware decoding Major CPU reduction
3 Define zones + required_zones per camera Biggest notification noise reduction
4 Enable face recognition, train family faces Suppress known person alerts
5 Install SgtBatten blueprint Rich notifications with cooldown/presence/time
6 Add Companion App for presence Suppress alerts when home
7 Configure time-based rules Night = full alerts, Day = zones only

References