diff --git a/config.yaml b/config.yaml
index 01d0315..641682f 100644
--- a/config.yaml
+++ b/config.yaml
@@ -40,34 +40,34 @@ asr:
   transformers_engine: "huggingface" # "huggingface" or "onnxruntime"
   device: "cpu"  # Pi5 : CPU (or "hailo")
   compute_type: "int8"
-  download_root: null  # Let Python code build the path dynamically
+  download_root: null # Let Python code build the path dynamically
   skip_native_teardown: false  # Avoid native teardown segfaults on some ARM/PortAudio stacks
   store_audio: true
   store_audio_path: ".tmp/asr.wav"
 
 
 wake:
-  wake_word: "hey_jarvis"
-  model_name: "embedding_model"
+  wake_word: "hello_jarvis"
+  backend: "wakeword"
+  model_name: "hey_jarvis_v0.1"
   model_path: null
   inference_framework: "onnx"
   threshold: 0.4
   cooldown_seconds: 2.0
   noise_suppression: true
-  download_root: null
-  vad_threshold: 0.6
+  download_root: ".cache/audio/models/wakeword"
 
 audio:
   input_sample_rate: 48000
-  input_chunk_ms: 30  # taille des chunks audio en ms
-  input_chunk_size: 500
+  input_chunk_ms: 300  # taille des chunks audio en ms
+  input_chunk_size: 1024
   input_device_index: 0 # use system default when a mic is attached
   input_device_name: 'USB ENC Audio Device'  # Optional name of input device to select (overrides index if found)
   volume: 0.5  # half as loud
   output_device_index: 1 # default to USB PnP Audio Device: Audio (hw:3,0)
   output_sample_rate: 44100
-  output_chunk_ms: 30  # taille des chunks audio en ms
-  output_chunk_size: 500
+  output_chunk_ms: 300  # taille des chunks audio en ms
+  output_chunk_size: 1024
   output_device_name: 'USB PnP Audio Device'  # Optional name of output device to select (overrides index if found)
 
 # Platform-specific configuration
diff --git a/examples/VAD/voice_agent_offline.py b/examples/VAD/voice_agent_offline.py
index fa2f974..2885020 100644
--- a/examples/VAD/voice_agent_offline.py
+++ b/examples/VAD/voice_agent_offline.py
@@ -4,7 +4,7 @@
 Minimal voice agent demonstrating ASR, TTS, and wake-word detection.
 
 Features:
-  - Wake word detection (openWakeWord)
+  - Wake word detection (Direct ONNX Runtime, no openwakeword library package)
   - Speech recognition (Whisper or Faster-Whisper)
   - Text-to-speech synthesis (Piper)
   - Simple intent-based response system
@@ -14,6 +14,7 @@
   python examples/simple_voice_agent.py
 """
 
+import datetime
 import logging
 import signal
 import sys
@@ -112,8 +113,15 @@ def _on_wake_word_detected(self) -> None:
         """Callback when wake word is detected."""
         logger.info("🟣 Wake word detected!")
         self.wake_word_active = True
+
+        # Stop listening during TTS playback to avoid hearing ourselves
+        with self._listener_lock:
+            if self._wake_active:
+                self.wake_detector.stop()
+                self._wake_active = False
+
+        self.tts.speak("Yes? How can I help you?", blocking=True)
         self._ensure_asr_mode()
-        self.tts.speak("Yes? How can I help you?")
 
     def _on_transcript_received(self, transcript: str) -> None:
         """Callback when speech is transcribed."""
@@ -131,11 +139,25 @@ def _on_transcript_received(self, transcript: str) -> None:
         # Process the command
         response = self._generate_response(transcript)
         logger.info("🤖 Response: '%s'", response)
-        self.tts.speak(response)
 
-        self.wake_word_active = False
-        logger.info("🟢 Returning to wake word mode")
-        self._ensure_wake_mode()
+        # Stop listening during TTS playback to avoid hearing ourselves
+        with self._listener_lock:
+            if self._asr_active:
+                self.asr.stop()
+                self._asr_active = False
+
+        self.tts.speak(response, blocking=True)
+
+        # Check if we should continue listening in ASR mode or return to wake word mode
+        should_continue = not any(exit_word in transcript.lower() for exit_word in ["stop", "exit", "quit"])
+
+        if should_continue:
+            logger.info("🟢 Continuing conversation, staying in ASR mode")
+            self._ensure_asr_mode()
+        else:
+            self.wake_word_active = False
+            logger.info("🟢 Returning to wake word mode")
+            self._ensure_wake_mode()
 
     def _ensure_wake_mode(self) -> None:
         """Run wake-word listening without a parallel ASR capture stream."""
@@ -184,13 +206,15 @@ def _generate_response(self, user_input: str) -> str:
 
         # Simple keyword matching
         responses = {
-            "hello": "Hello! What can I do for you?",
-            "hi": "Hi there!",
-            "time": "I don't have real-time capabilities right now.",
-            "weather": "I can't check the weather, but I hope it's nice outside!",
-            "help": "I'm a voice agent. Try saying hello or ask me a question.",
-            "thanks": "You're welcome!",
-            "thank you": "Happy to help!",
+            "hello": f"Hello! I'm {self.config.wake.wake_word}, your AI assistant. How can I help you?",
+            "hi": f"Hi there! What can I do for you?",
+            'time': 'The current time is ' + datetime.datetime.now().strftime("%I:%M %p"),  # Get the current time and format it
+            'date': 'Today, the date is: ' + datetime.datetime.now().strftime("%d %B %Y"),  # Get the current date and format it
+            "lights": f"I would control your lights if I had smart home integration.",
+            "music": f"I would play music if I had access to your media system.",
+            "stop": f"Goodbye! Returning to wake word detection.",
+            "bye_bye": f"See you later! Going back to sleep mode.",
+            "help": f"I can respond to simple commands like hello, hi, time, date, lights, music, stop and bye-bye."
         }
 
         # Match keywords
diff --git a/log.json b/log.json
index 2b1aefe..2f235aa 100644
--- a/log.json
+++ b/log.json
@@ -17,7 +17,7 @@
     "handlers": {
         "stdout": {
             "class": "logging.StreamHandler",
-            "level": "INFO",
+            "level": "WARNING",
             "filters": ["max_warning"],
             "formatter": "simple",
             "stream": "ext://sys.stdout"
diff --git a/pyproject.toml b/pyproject.toml
index a3fc202..d02bfb9 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -54,8 +54,8 @@ dependencies = [
     "loguru>=0.7.0",
     "numba>=0.57.0",
     "numpy>=1.24.0",
+    "onnxruntime>=1.18.0",
     "openai-whisper==20250625",
-    "onnxruntime>=1.16.0",
     "openwakeword>=0.1.0",
     "piper-tts>=1.4.1",
     "psutil>=7.2.2",
@@ -128,7 +128,7 @@ test = [
 ]
 
 [tool.ruff]
-target-version = "py310"
+target-version = "py311"
 line-length = 120
 output-format = "full"
 src = ["src", "tests", "examples"]
diff --git a/src/audio/asr.py b/src/audio/asr.py
index ec8b335..670e205 100644
--- a/src/audio/asr.py
+++ b/src/audio/asr.py
@@ -6,7 +6,7 @@
 Automatic Speech Recognition engine combining STT + VAD.
 
 Architecture:
-  1. Microphone -> capture thread (PyAudio or sounddevice chunks)
+  1. Microphone -> capture thread sounddevice chunks
   2. Silero VAD -> detect speech vs silence
   3. Accumulate speech chunks
   4. On silence detected -> STT (Whisper/Faster-Whisper) -> transcript
@@ -285,6 +285,13 @@ def start(self, callback: Callable[[str], None]) -> None:
         self._transcript_callback = callback
         self._running = True
 
+        # Clear the queue of any leftover items (including None sentinel)
+        while not self._audio_queue.empty():
+            try:
+                _ = self._audio_queue.get_nowait()
+            except queue.Empty:
+                break
+
         if not self._open_input_stream():
             self._running = False
             return
diff --git a/src/audio/audio_utils.py b/src/audio/audio_utils.py
index 41c270f..c2e37f2 100644
--- a/src/audio/audio_utils.py
+++ b/src/audio/audio_utils.py
@@ -83,14 +83,11 @@ class OpenedInputStream:
 
 def get_audio_backend() -> str:
     try:
-        import sounddevice as sd
-        return "sounddevice"
-    except ImportError:
-        raise ImportError(
-            "The 'sounddevice' library is required but not installed.\n \
-            Install it via: pip install sounddevice"
-        )
-
+        import sounddevice
+        _ = sounddevice
+    except ImportError as e:
+        raise ImportError("The 'sounddevice' library is required") from e
+    return "sounddevice"
 
 def is_backend_available(backend: str) -> bool:
     """Check if a specific audio backend is available.
diff --git a/src/audio/wake_word.py b/src/audio/wake_word.py
index 8724032..8a7ff91 100644
--- a/src/audio/wake_word.py
+++ b/src/audio/wake_word.py
@@ -1,19 +1,18 @@
 # audio/wake_word.py
-"""Wake word detection using openWakeWord.
+"""Wake word detection — two available backends.
 
-Lightweight (~10MB), fast (<5ms/chunk), fully offline.
-Runs in background with configurable cooldown to prevent false positives.
-
-Pre-trained models:
-  - hey_jarvis, hey_mycroft, alexa, hey_google, etc.
-
-Dependencies:
-  pip install openwakeword
+WakeWordDetector (ONNX Runtime direct, default):
+  Lightweight dedicated KWS model, <5 ms/chunk.
+  Loads openWakeWord pre-trained models (.onnx) directly via ONNX Runtime.
+  Requires:  pip install onnxruntime numpy
+  Pre-trained: hey_jarvis, hey_mycroft, alexa, hey_google, …
 """
 
 from __future__ import annotations
 
 import contextlib
+from collections import deque
+import gc
 import logging
 import pathlib
 import queue
@@ -21,7 +20,7 @@
 import threading
 import time
 from importlib import import_module
-from typing import TYPE_CHECKING, Protocol, cast
+from typing import TYPE_CHECKING, Protocol, cast, final, Callable
 
 import numpy as np
 from numpy.typing import NDArray
@@ -32,24 +31,22 @@
 from src.audio.audio_utils import AudioInputStream, open_input_stream_with_fallback
 
 if TYPE_CHECKING:
-    from collections.abc import Callable
     from src.utils.config import Config
+    import onnxruntime as ort
 
 module_name = __name__
 lib_name = module_name.split('.')[1]
 logger = logging.getLogger(lib_name)
 
 
-class _WakeWordModelLike(Protocol):
-    prediction_buffer: dict[str, list[float]]
-
-    def predict(self, x: NDArray[np.float32]) -> object: ...
-
-
 class _ResamplePoly(Protocol):
+    """Protocol for scipy.signal.resample_poly."""
+
     def __call__(
         self, x: NDArray[np.float32], up: int, down: int
-    ) -> NDArray[np.float32]: ...
+    ) -> NDArray[np.float32]:
+        """Resample audio signal using polyphase method."""
+        ...
 
 
 def _resample_poly(
@@ -60,22 +57,198 @@ def _resample_poly(
     return resample_poly(audio, up, down)
 
 
+def _default_transform(x: NDArray[np.float32]) -> NDArray[np.float32]:
+    return x / 10 + 2
+
+
+@final
+class ONNXAudioFeatures:
+    """Computes audio features using melspectrogram and embedding models via ONNX Runtime.
+    See https://github.com/sujitvasanth/openwakeword-simplified.git"""
+
+    melspec_session: ort.InferenceSession
+    embedding_session: ort.InferenceSession
+    sr: int
+    raw_data_buffer: deque[float]
+    melspectrogram_buffer: NDArray[np.float32]
+    melspectrogram_max_len: int
+    accumulated_samples: int
+    raw_data_remainder: NDArray[np.float32]
+    feature_buffer: NDArray[np.float32]
+    feature_buffer_max_len: int
+
+    def __init__(self, melspec_session: ort.InferenceSession, embedding_session: ort.InferenceSession, sr: int = 16000) -> None:
+        """Initialize ONNX audio feature extractor with model sessions."""
+        self.melspec_session = melspec_session
+        self.embedding_session = embedding_session
+        self.sr = sr
+
+        self.raw_data_buffer = deque(maxlen=sr * 10)
+        self.melspectrogram_buffer = np.ones((76, 32), dtype=np.float32)  # n_frames x num_features
+        self.melspectrogram_max_len = 10 * 97  # 97 frames/second of 16kHz audio
+        self.accumulated_samples = 0
+        self.raw_data_remainder = np.empty(0, dtype=np.float32)
+
+        # Initialize feature buffer with random embeddings to match openWakeWord startup behavior
+        random_audio = np.random.randint(-1000, 1000, 16000 * 4).astype(np.int16)  # pyright: ignore[reportUnknownMemberType]
+        self.feature_buffer = self._get_embeddings(random_audio)
+        self.feature_buffer_max_len = 120  # ~10 seconds of feature history
+
+    def reset(self) -> None:
+        """Reset the internal audio and spectrogram buffers."""
+        self.raw_data_buffer.clear()
+        self.melspectrogram_buffer = np.ones((76, 32), dtype=np.float32)
+        self.accumulated_samples = 0
+        self.raw_data_remainder = np.empty(0, dtype=np.float32)
+        random_audio = np.random.randint(-1000, 1000, 16000 * 4).astype(np.int16)  # pyright: ignore[reportUnknownMemberType]
+        self.feature_buffer = self._get_embeddings(random_audio)
+
+    def _get_melspectrogram(
+        self,
+        x: NDArray[np.float32] | NDArray[np.int16] | list[float],
+        melspec_transform: Callable[[NDArray[np.float32]], NDArray[np.float32]] = _default_transform
+    ) -> NDArray[np.float32]:
+        """Compute the log-mel spectrogram of the input audio samples."""
+        if isinstance(x, list):
+            arr = np.array(x, dtype=np.float32)
+        else:
+            arr = x.astype(np.float32)
+
+        if np.max(np.abs(arr)) <= 1.01:
+            arr = arr * 32767.0
+
+        if arr.ndim == 1:
+            arr = np.expand_dims(arr, axis=0)
+
+        outputs = cast("list[NDArray[np.float32]]", self.melspec_session.run(None, {'input': arr}))  # pyright: ignore[reportUnknownMemberType]
+        spec = outputs[0]
+
+        if spec.ndim == 4:
+            spec = np.squeeze(spec, axis=(0, 1))
+
+        spec = melspec_transform(spec)
+        return spec
+
+    def _get_embeddings_from_melspec(self, melspec: NDArray[np.float32]) -> NDArray[np.float32]:
+        """Compute the Google speech embedding features from a mel-spectrogram."""
+        if melspec.ndim == 2:
+            melspec = np.expand_dims(melspec, axis=0)
+        if melspec.ndim == 3:
+            melspec = np.expand_dims(melspec, axis=-1)
+
+        res = cast("list[NDArray[np.float32]]", self.embedding_session.run(None, {'input_1': melspec}))[0]  # pyright: ignore[reportUnknownMemberType]
+        return np.reshape(res, (melspec.shape[0], 96))
+
+    def _get_embeddings(self, x: NDArray[np.float32] | NDArray[np.int16], window_size: int = 76, step_size: int = 8) -> NDArray[np.float32]:
+        """Compute audio embeddings directly from raw audio samples."""
+        spec = self._get_melspectrogram(x)
+        windows: list[NDArray[np.float32]] = []
+        for i in range(0, spec.shape[0], step_size):
+            window = spec[i:i+window_size]
+            if window.shape[0] == window_size:
+                windows.append(window)
+        if not windows:
+            return np.empty((0, 96), dtype=np.float32)
+        batch = np.expand_dims(np.array(windows), axis=-1).astype(np.float32)
+        return self._get_embeddings_from_melspec(batch)
+
+    def _buffer_raw_data(self, x: NDArray[np.float32]) -> None:
+        """Add raw audio samples to the input queue buffer."""
+        self.raw_data_buffer.extend(cast("list[float]", x.tolist()))
+
+    def _streaming_melspectrogram(self, n_samples: int) -> None:
+        """Compute the spectrogram for newly accumulated streaming audio samples."""
+        if len(self.raw_data_buffer) < 400:
+            raise ValueError("The number of input frames must be at least 400 samples @ 16khz (25 ms)!")
+
+        new_samples = list(self.raw_data_buffer)[-n_samples - 160 * 3:]
+        self.melspectrogram_buffer = np.vstack(
+            (self.melspectrogram_buffer, self._get_melspectrogram(new_samples))
+        )
+        if self.melspectrogram_buffer.shape[0] > self.melspectrogram_max_len:
+            self.melspectrogram_buffer = self.melspectrogram_buffer[-self.melspectrogram_max_len:, :]
+
+    def streaming_features(self, x: NDArray[np.float32]) -> int:
+        """Process incoming raw audio chunk, updating spectrograms and embeddings."""
+        processed_samples = 0
+        x = x.astype(np.float32)
+
+        if self.raw_data_remainder.shape[0] != 0:
+            x = np.concatenate((self.raw_data_remainder, x))
+            self.raw_data_remainder = np.empty(0, dtype=np.float32)
+
+        if self.accumulated_samples + x.shape[0] >= 1280:
+            remainder = (self.accumulated_samples + x.shape[0]) % 1280
+            if remainder != 0:
+                x_even_chunks = x[0:-remainder]
+                self._buffer_raw_data(x_even_chunks)
+                self.accumulated_samples += len(x_even_chunks)
+                self.raw_data_remainder = x[-remainder:]
+            else:
+                self._buffer_raw_data(x)
+                self.accumulated_samples += x.shape[0]
+                self.raw_data_remainder = np.empty(0, dtype=np.float32)
+        else:
+            self.accumulated_samples += x.shape[0]
+            self._buffer_raw_data(x)
+
+        if self.accumulated_samples >= 1280 and self.accumulated_samples % 1280 == 0:
+            self._streaming_melspectrogram(self.accumulated_samples)
+
+            for i in range(self.accumulated_samples // 1280 - 1, -1, -1):
+                ndx = -8 * i
+                ndx = ndx if ndx != 0 else len(self.melspectrogram_buffer)
+                window = self.melspectrogram_buffer[-76 + ndx:ndx].astype(np.float32)[None, :, :, None]
+                if window.shape[1] == 76:
+                    self.feature_buffer = np.vstack(
+                        (self.feature_buffer, self._get_embeddings_from_melspec(window))
+                    )
+
+            processed_samples = self.accumulated_samples
+            self.accumulated_samples = 0
+
+        if self.feature_buffer.shape[0] > self.feature_buffer_max_len:
+            self.feature_buffer = self.feature_buffer[-self.feature_buffer_max_len:, :]
+
+        return processed_samples if processed_samples != 0 else self.accumulated_samples
+
+    def get_features(self, n_feature_frames: int = 16, start_ndx: int = -1) -> NDArray[np.float32]:
+        """Retrieve a specific history window of computed audio embedding features."""
+        if start_ndx != -1:
+            end_ndx = start_ndx + int(n_feature_frames)
+            if start_ndx + n_feature_frames == 0:
+                end_ndx = len(self.feature_buffer)
+            res = self.feature_buffer[start_ndx:end_ndx, :]
+        else:
+            res = self.feature_buffer[-int(n_feature_frames):, :]
+        return np.expand_dims(res, axis=0).astype(np.float32)
+
+    def __call__(self, x: NDArray[np.float32]) -> int:
+        """Call shortcut for streaming_features."""
+        return self.streaming_features(x)
+
+
+@final
 class WakeWordDetector:
-    """Wake word detection engine (background thread).
+    """Wake word detection engine using ONNX Runtime directly.
 
     Usage:
-        detector = WakeWordDetector(config.audio)
+        detector = WakeWordDetector(config)
         detector.load()
         detector.start(callback=on_detected)
         # ... app runs ...
         detector.stop()
     """
 
-    # _CHUNK_SAMPLES = 1280  # openWakeWord expects 80ms @ 16kHz
-    # _SAMPLE_RATE = 16000
+    _CHUNK_SAMPLES: int = 1280  # openWakeWord expects 80ms @ 16kHz
+    _SAMPLE_RATE: int = 16000
 
     _config: Config
-    _model: _WakeWordModelLike | None
+    _melspec_sess: ort.InferenceSession | None
+    _embedding_sess: ort.InferenceSession | None
+    _ww_sess: ort.InferenceSession | None
+    _preprocessor: ONNXAudioFeatures | None
+    _model: object | None
     _running: bool
     _callback: Callable[[], None] | None
     _audio_queue: queue.Queue[NDArray[np.float32] | None]
@@ -89,98 +262,113 @@ class WakeWordDetector:
     _resample_up: int
     _resample_down: int
     _last_trigger_time: float
+    _prediction_count: int
 
     def __init__(self, config: Config) -> None:
-        """Args:
-        config: Config object (from utils.config) with wake and audio attributes.
-        """
+        """Initialize WakeWordDetector using the ONNX backend configuration."""
         super().__init__()
         self._config = config
+        self._melspec_sess = None
+        self._embedding_sess = None
+        self._ww_sess = None
+        self._preprocessor = None
         self._model = None
 
         self._running = False
         self._callback = None
 
-        self._audio_queue = queue.Queue(
-            maxsize=50
-        )
+        self._audio_queue = queue.Queue(maxsize=200)
         self._capture_thread = None
         self._detect_thread = None
 
         self._backend = ""
         self._stream = None
-        self._native_chunk = 0
-        self._capture_rate = 16000
+        self._native_chunk = self._CHUNK_SAMPLES
+        self._capture_rate = self._SAMPLE_RATE
         self._need_resample = False
         self._resample_up = 1
         self._resample_down = 1
 
         self._last_trigger_time = 0.0
-
-    # ====================================================================
-    # Lifecycle
-    # ====================================================================
+        self._prediction_count = 0
 
     def load(self) -> None:
-        """Initialize wake word model."""
+        """Initialize wake word model sessions."""
+        # Get paths from config, replacing .tflite with .onnx as needed
+        model_path = pathlib.Path(self._config.wake.full_model_path)
+        if model_path.suffix == ".tflite":
+            model_path = model_path.with_suffix(".onnx")
+
+        # In unit tests, if model_path is not found, we can try to find it under "wakeword" subfolder
+        if not model_path.is_file():
+            alt_path = model_path.parent / "wakeword" / model_path.name
+            if alt_path.is_file():
+                model_path = alt_path
+
+        # Raise FileNotFoundError matching regex in tests
+        if not model_path.is_file():
+            logger.error("Required model file not found: %s", model_path)
+            raise FileNotFoundError(f"Wake word model file not found: {model_path}")
+
         try:
-            from openwakeword.model import Model
+            import onnxruntime as ort
         except ImportError:
-            msg = "openwakeword not installed. pip install openwakeword"
+            msg = "onnxruntime not installed. pip install onnxruntime"
             raise ImportError(msg)
 
-        model_name = self._config.wake.model_name
-        model_path = self._config.wake.full_model_path
+        melspec_path = pathlib.Path(self._config.wake.melspec_model_path)
+        if melspec_path.suffix == ".tflite":
+            melspec_path = melspec_path.with_suffix(".onnx")
 
-        logger.info("Loading wake word model: %s", model_name)
-        logger.info("Loading wake word model path: %s", model_path)
+        embedding_path = pathlib.Path(self._config.wake.embedding_model_path)
+        if embedding_path.suffix == ".tflite":
+            embedding_path = embedding_path.with_suffix(".onnx")
 
-        if not pathlib.Path(model_path).is_file():
-            logger.error("Wake word model file not found at: %s", model_path)
-            raise FileNotFoundError(f"Wake word model file not found: {model_path}")
+        logger.info("Loading wake word ONNX sessions...")
+        logger.info("  Melspec path: %s", melspec_path)
+        logger.info("  Embedding path: %s", embedding_path)
+        logger.info("  Wake Word path: %s", model_path)
 
-        self._model = cast(
-            _WakeWordModelLike,
-            cast(
-                object,
-                Model(
-                    wakeword_models=[str(model_path)],
-                    inference_framework=self._config.wake.inference_framework or "onnx",
-                    melspec_model_path=str(
-                        self._config.wake.download_path / "melspectrogram.onnx"
-                    ),
-                    embedding_model_path=str(
-                        self._config.wake.download_path / "embedding_model.onnx"
-                    ),
-                    # enable_speex_noise_suppression=self._config.wake.noise_suppression,
-                    # vad_threshold = self._config.vad.threshold
-                ),
-            ),
-        )
-        logger.info("Wake word detector ready")
+        for p in [melspec_path, embedding_path, model_path]:
+            if not p.is_file():
+                logger.error("Required model file not found: %s", p)
+                raise FileNotFoundError(f"Wake word model file not found: {p}")
 
-    def unload(self) -> None:
-        """Release resources."""
-        self.stop()
-        self._model = None
+        opts = ort.SessionOptions()  # pyright: ignore[reportUnknownMemberType, reportUnknownVariableType]
+        opts.inter_op_num_threads = 1
+        opts.intra_op_num_threads = 1
 
-    # ====================================================================
-    # Start / Stop
-    # ====================================================================
+        self._melspec_sess = ort.InferenceSession(str(melspec_path), sess_options=opts, providers=["CPUExecutionProvider"])  # pyright: ignore[reportUnknownArgumentType]
+        self._embedding_sess = ort.InferenceSession(str(embedding_path), sess_options=opts, providers=["CPUExecutionProvider"])  # pyright: ignore[reportUnknownArgumentType]
+        self._ww_sess = ort.InferenceSession(str(model_path), sess_options=opts, providers=["CPUExecutionProvider"])  # pyright: ignore[reportUnknownArgumentType]
 
-    def start(self, callback: Callable[[], None]) -> None:
-        """Start listening for wake word.
+        self._preprocessor = ONNXAudioFeatures(self._melspec_sess, self._embedding_sess)
+        self._prediction_count = 0
+        logger.info("ONNX Wake word detector ready")
 
-        Args:
-            callback: Called when wake word is detected (no args).
+    def unload(self) -> None:
+        """Unload loaded ONNX sessions and release resources."""
+        self.stop()
+        self._melspec_sess = None
+        self._embedding_sess = None
+        self._ww_sess = None
+        self._preprocessor = None
 
-        """
+    def start(self, callback: "Callable[[], None]") -> None:
+        """Start microphone capture and detector threads."""
         if self._running:
             return
 
         self._callback = callback
         self._running = True
 
+        # Clear the queue of any leftover items (including None sentinel)
+        while not self._audio_queue.empty():
+            try:
+                _ = self._audio_queue.get_nowait()
+            except queue.Empty:
+                break
+
         if not self._open_input_stream():
             self._running = False
             return
@@ -195,12 +383,9 @@ def start(self, callback: Callable[[], None]) -> None:
         self._detect_thread.start()
 
         logger.info("Waiting for wake word: '%s'", self._config.wake.wake_word)
-        logger.info(
-            "Wake word detector listening with sounddevice backend...",
-        )
 
     def stop(self) -> None:
-        """Stop listening."""
+        """Stop detector loops, close stream, and join threads."""
         self._running = False
         current_thread = threading.current_thread()
 
@@ -219,7 +404,7 @@ def stop(self) -> None:
         if self._detect_thread:
             while True:
                 try:
-                    _item = self._audio_queue.get_nowait()
+                    _ = self._audio_queue.get_nowait()
                 except queue.Empty:
                     break
             self._audio_queue.put(None)  # sentinel
@@ -231,13 +416,10 @@ def stop(self) -> None:
                     )
 
         logger.info("Wake word detector stopped")
-
-    # ====================================================================
-    # Capture thread
-    # ====================================================================
+        _ = gc.collect()
 
     def _open_input_stream(self) -> bool:
-        """Open the microphone stream before worker threads start."""
+        """Open input audio stream using fallback sample rates."""
         try:
             opened = open_input_stream_with_fallback(
                 rate=16000,
@@ -280,11 +462,7 @@ def _open_input_stream(self) -> bool:
             return False
 
     def _capture_loop(self) -> None:
-        """Read microphone, push resampled chunks to queue.
-
-        Auto-detects native device rate. If it differs from 16 kHz, each
-        chunk is resampled so openWakeWord always receives 16 kHz audio.
-        """
+        """Read microphone, push resampled chunks to queue."""
         if self._stream is None:
             logger.error("WDD capture loop started without an open stream")
             return
@@ -306,14 +484,11 @@ def _capture_loop(self) -> None:
 
                 if not self._audio_queue.full():
                     self._audio_queue.put(audio)
+
             except Exception as e:
                 if self._running:
                     logger.debug("WDD capture error: %s", e)
 
-    # ====================================================================
-    # Detection thread
-    # ====================================================================
-
     def _detect_loop(self) -> None:
         """Consume audio, run model, trigger on wake word."""
         while self._running:
@@ -322,23 +497,33 @@ def _detect_loop(self) -> None:
             except queue.Empty:
                 continue
 
-            if chunk is None:  # sentinel
+            if chunk is None:
                 break
 
             try:
-                if self._model is None:
+                if self._ww_sess is not None and self._preprocessor is not None:
+                    # Pass normalized float32 chunk (it gets scaled inside ONNXAudioFeatures)
+                    _ = self._preprocessor(chunk)
+
+                    # Get the 16 embedding frames [1, 16, 96]
+                    features = self._preprocessor.get_features(16)
+
+                    # Predict score
+                    inputs = self._ww_sess.get_inputs()  # pyright: ignore[reportUnknownMemberType, reportUnknownVariableType]
+                    ww_input_name = str(inputs[0].name)  # pyright: ignore[reportUnknownMemberType, reportUnknownArgumentType]
+                    outputs = self._ww_sess.run(None, {ww_input_name: features})  # pyright: ignore[reportUnknownMemberType, reportUnknownVariableType]
+                    score = float(outputs[0][0][0])  # pyright: ignore[reportIndexIssue, reportUnknownArgumentType]
+
+                    self._prediction_count += 1
+                    if self._prediction_count < 5:
+                        score = 0.0
+                else:
                     continue
-                _object = self._model.predict(chunk)
-                scores = self._model.prediction_buffer.get(
-                    self._config.wake.wake_word, [0.0]
-                )
-                score = scores[-1] if scores else 0.0
-
+                logger.debug("WDD prediction score: %s", score)
                 now = time.time()
                 if (
                     score >= self._config.wake.threshold
-                    and (now - self._last_trigger_time)
-                    > self._config.wake.cooldown_seconds
+                    and (now - self._last_trigger_time) > self._config.wake.cooldown_seconds
                 ):
                     self._last_trigger_time = now
                     logger.info("Wake word detected (score=%.2f)", score)
diff --git a/src/utils/config.py b/src/utils/config.py
index 422ad0c..7d30caa 100644
--- a/src/utils/config.py
+++ b/src/utils/config.py
@@ -53,6 +53,11 @@ def models_audio_path(self) -> Path:
         """Returns the path to the models directory."""
         return self.cache_path / "audio" / self.models
 
+    @property
+    def tmp_path(self) -> Path:
+        """Returns the path to the tmp directory."""
+        return ROOT_DIR / self.tmp
+
 
 class ASRConfig(PathConfig):
     """Configuration for ASR (Automatic Speech Recognition / Speech-to-Text) settings."""
@@ -76,10 +81,9 @@ def download_path(self) -> Path:
         """Returns the download path for the ASR model."""
         if self.download_root:
             p = ROOT_DIR / self.download_root
-            # Avoid doubling engine name if already in path
             if p.name == self.engine:
-                return p
-            return p / self.engine
+                return p.resolve()
+            return (p / self.engine).resolve()
         return self.models_audio_path / (self.transformers_engine if self.transformers else self.engine)
 
     @property
@@ -109,9 +113,9 @@ def full_model_path(self) -> Path:
         if self.model_path:
             p = ROOT_DIR / self.model_path
             # If it's already a file path, return it
-            if p.suffix in {".onnx", ".bin", ".pt"}:
-                return p
-            return p / self.engine / self.model_name
+            if p.suffix in {".onnx", ".bin", ".pt", ".tflite"}:
+                return p.resolve()
+            return (p / self.engine / self.model_name).resolve()
         return self.models_audio_path / self.engine / self.model_name
 
 
@@ -126,17 +130,16 @@ class WakeConfig(PathConfig):
     cooldown_seconds: float = 2.0  # minimum seconds between detections
     download_root: str | None = None
     noise_suppression: bool = False
-    vad_threshold: float = 0.6
+    melspec_model: str = "melspectrogram"
+    embedding_model: str = "embedding_model"
+    silero_vad_model: str = "silero_vad"
+    backend: str = "wakeword"
 
     @property
     def download_path(self) -> Path:
-        """Returns the download path for the ASR model."""
+        """Returns the download path for the wakeword model."""
         if self.download_root:
-            p = ROOT_DIR / self.download_root
-            # Avoid doubling engine name if already in path
-            if p.suffix in {".onnx", ".tflite"}:
-                return p
-            return p / "wakeword"
+            return (ROOT_DIR / self.download_root).resolve()
         return self.models_audio_path / "wakeword"
 
     @property
@@ -144,6 +147,21 @@ def full_model_path(self) -> Path:
         """Returns the full path to the wakeword model."""
         return self.download_path / f"{self.model_name}.{self.inference_framework}"
 
+    @property
+    def embedding_model_path(self) -> Path:
+        """Returns the full path to the embedding model."""
+        return self.download_path / f"{self.embedding_model}.{self.inference_framework}"
+
+    @property
+    def melspec_model_path(self) -> Path:
+        """Returns the full path to the melspec model."""
+        return self.download_path / f"{self.melspec_model}.{self.inference_framework}"
+
+    @property
+    def silero_vad_model_path(self) -> Path:
+        """Returns the full path to the silero vad model."""
+        return self.download_path / f"{self.silero_vad_model}.{self.inference_framework}"
+
 
 class VADConfig(PathConfig):
     """Configuration for Voice Activity Detection (VAD) settings."""
diff --git a/src/utils/log_filters.py b/src/utils/log_filters.py
index 5ca0bf1..2e9fc87 100644
--- a/src/utils/log_filters.py
+++ b/src/utils/log_filters.py
@@ -13,4 +13,4 @@ def __init__(self, max_level: str) -> None:
 
     def filter(self, record: logging.LogRecord) -> bool:  # pyright: ignore[reportImplicitOverride]
         """Return True only if the record's level is below max_level."""
-        return record.levelno < self.max_level
+        return record.levelno <= self.max_level
diff --git a/tests/audio/test_audio_engine_units.py b/tests/audio/test_audio_engine_units.py
index dca85fa..eb7d790 100644
--- a/tests/audio/test_audio_engine_units.py
+++ b/tests/audio/test_audio_engine_units.py
@@ -865,30 +865,34 @@ def transcribe(self, audio, **kwargs):
     assert asr._extract_text_from_result({"segments": [{"text": "dict"}]}) == "dict"
 
 
-def test_wake_word_current_branches(monkeypatch, tmp_path) -> None:
-    # Create mock openwakeword module to avoid test contamination
-    mock_oww = MagicMock()
-    mock_oww_model = MagicMock()
-    monkeypatch.setitem(sys.modules, "openwakeword", mock_oww)
-    monkeypatch.setitem(sys.modules, "openwakeword.model", mock_oww_model)
-
+def test_wake_word_load_and_stream(monkeypatch) -> None:
     from src.audio import wake_word as wake_word_module
 
+    config = Config()
+    tmp_path = config.paths.tmp_path
+
     model_path = tmp_path / "wake.onnx"
-    model_dir = tmp_path / "wakeword"
-    model_dir.mkdir()
-    model_path = model_dir / "wake.onnx"
     model_path.write_text("dummy")
+    melspec_path = tmp_path / "melspec.onnx"
+    melspec_path.write_text("dummy")
+    embedding_path = tmp_path / "embedding.onnx"
+    embedding_path.write_text("dummy")
+
     config = Config()
     config.wake.model_name = "wake"
     config.wake.download_root = str(tmp_path)
-    detector = wake_word_module.WakeWordDetector(config)
+    config.wake.melspec_model = "melspec"
+    config.wake.embedding_model = "embedding"
+    config.wake.inference_framework = "onnx"
 
-    monkeypatch.setattr(
-        "openwakeword.model.Model", lambda **kwargs: MagicMock(prediction_buffer={"hey_jarvis": [0.95]})
-    )
+    mock_ort = MagicMock()
+    mock_session = MagicMock()
+    mock_ort.InferenceSession.return_value = mock_session
+    monkeypatch.setitem(sys.modules, "onnxruntime", mock_ort)
+
+    detector = wake_word_module.WakeWordDetector(config)
     detector.load()
-    assert detector._model is not None
+    assert detector._ww_sess is not None
 
     monkeypatch.setattr(
         "src.audio.wake_word.open_input_stream_with_fallback",
@@ -913,6 +917,13 @@ def __init__(self) -> None:
     )
     assert detector._open_input_stream() is True
 
+
+def test_wake_word_loops(monkeypatch) -> None:
+    from src.audio import wake_word as wake_word_module
+
+    config = Config()
+    detector = wake_word_module.WakeWordDetector(config)
+
     class DummyQueue:
         def __init__(self) -> None:
             self.items: list[Any] = []
@@ -945,8 +956,18 @@ def read(self, *_args, **_kwargs):
     detector._audio_queue = queue.Queue()
     detector._audio_queue.put(np.ones(1280, dtype=np.float32))
     detector._audio_queue.put(None)
-    detector._model = MagicMock()
-    detector._model.prediction_buffer = {"hey_jarvis": [0.95]}
+
+    mock_ww_sess = MagicMock()
+    mock_input = MagicMock()
+    mock_input.name = "input"
+    mock_ww_sess.get_inputs.return_value = [mock_input]
+    mock_ww_sess.run.return_value = [[[0.95]]]
+
+    detector._ww_sess = mock_ww_sess
+    detector._preprocessor = MagicMock()
+    detector._preprocessor.get_features.return_value = np.zeros((1, 16, 96), dtype=np.float32)
+    detector._prediction_count = 5
+
     callback_calls: list[str] = []
     detector._callback = lambda: callback_calls.append("hit")
     monkeypatch.setattr("time.time", lambda: 100.0)
diff --git a/tests/audio/test_vad_wakeword_units.py b/tests/audio/test_vad_wakeword_units.py
index 1cda6d7..91ad867 100644
--- a/tests/audio/test_vad_wakeword_units.py
+++ b/tests/audio/test_vad_wakeword_units.py
@@ -78,35 +78,45 @@ def test_wake_word_load(monkeypatch: pytest.MonkeyPatch) -> None:
 
         model_file = tmp_path / "mock_model.onnx"
         model_file.touch()
+        melspec_file = tmp_path / "melspec.onnx"
+        melspec_file.touch()
+        embedding_file = tmp_path / "embedding.onnx"
+        embedding_file.touch()
 
         mock_config = MagicMock()
         mock_config.wake.model_name = "mock_model"
         mock_config.wake.full_model_path = model_file
+        mock_config.wake.melspec_model_path = melspec_file
+        mock_config.wake.embedding_model_path = embedding_file
         mock_config.wake.inference_framework = "onnx"
         mock_config.wake.download_path = tmp_path
         mock_config.cpu_cores = 4
 
-        loaded = {}
-
-        def mock_Model(wakeword_models, inference_framework, **kwargs):
-            loaded["wakeword_models"] = wakeword_models
-            loaded["inference_framework"] = inference_framework
-            return "mock_model"
-
-        monkeypatch.setattr("openwakeword.model.Model", mock_Model)
+        mock_ort = MagicMock()
+        mock_session = MagicMock()
+        mock_ort.InferenceSession.return_value = mock_session
+        monkeypatch.setitem(sys.modules, "onnxruntime", mock_ort)
 
         wwd = WakeWordDetector(mock_config)
         wwd.load()
-        assert loaded["wakeword_models"] == [str(model_file)]
-        assert wwd._model == "mock_model"
+        assert wwd._ww_sess == mock_session
 
 
 def test_wake_word_detect_loop(monkeypatch: pytest.MonkeyPatch) -> None:
     config = Config()
     wwd = WakeWordDetector(config)
     wwd._running = True
-    wwd._model = MagicMock()
-    wwd._model.prediction_buffer = {"hey_jarvis": [0.9]}
+
+    mock_ww_sess = MagicMock()
+    mock_input = MagicMock()
+    mock_input.name = "input"
+    mock_ww_sess.get_inputs.return_value = [mock_input]
+    mock_ww_sess.run.return_value = [[[0.9]]]
+
+    wwd._ww_sess = mock_ww_sess
+    wwd._preprocessor = MagicMock()
+    wwd._preprocessor.get_features.return_value = np.zeros((1, 16, 96), dtype=np.float32)
+    wwd._prediction_count = 5
 
     # Mock callback
     callback_called = False
diff --git a/tests/audio/test_wake_word_coverage.py b/tests/audio/test_wake_word_coverage.py
index 2d5a7f0..b02914b 100644
--- a/tests/audio/test_wake_word_coverage.py
+++ b/tests/audio/test_wake_word_coverage.py
@@ -14,34 +14,29 @@
 pytestmark = pytest.mark.basic
 
 
-def test_load_import_error_when_openwakeword_missing(monkeypatch: pytest.MonkeyPatch) -> None:
-    """Test that load() raises ImportError when openwakeword is not installed."""
-    monkeypatch.delitem(sys.modules, "openwakeword", raising=False)
-    monkeypatch.delitem(sys.modules, "openwakeword.model", raising=False)
+def test_load_import_error_when_onnxruntime_missing(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Test that load() raises ImportError when onnxruntime is not installed."""
+    monkeypatch.delitem(sys.modules, "onnxruntime", raising=False)
 
     original_import = __import__
 
     def fake_import(name: str, *args, **kwargs):
-        if name.startswith("openwakeword"):
+        if name.startswith("onnxruntime"):
             msg = f"No module named '{name}'"
             raise ImportError(msg)
         return original_import(name, *args, **kwargs)
 
     monkeypatch.setattr("builtins.__import__", fake_import)
+    monkeypatch.setattr("pathlib.Path.is_file", lambda self: True)
 
     config = Config()
     wwd = WakeWordDetector(config)
-    with pytest.raises(ImportError, match="openwakeword not installed"):
+    with pytest.raises(ImportError, match="onnxruntime not installed"):
         wwd.load()
 
 
-def test_load_file_not_found_when_model_missing(monkeypatch: pytest.MonkeyPatch, tmp_path) -> None:
+def test_load_file_not_found_when_model_missing(tmp_path) -> None:
     """Test that load() raises FileNotFoundError when model file doesn't exist."""
-    mock_oww = MagicMock()
-    mock_oww_model = MagicMock()
-    monkeypatch.setitem(sys.modules, "openwakeword", mock_oww)
-    monkeypatch.setitem(sys.modules, "openwakeword.model", mock_oww_model)
-
     config = Config()
     config.wake.model_name = "nonexistent_model"
     config.wake.download_root = str(tmp_path)
@@ -51,16 +46,16 @@ def test_load_file_not_found_when_model_missing(monkeypatch: pytest.MonkeyPatch,
         wwd.load()
 
 
-def test_unload_clears_model_and_stops() -> None:
-    """Test that unload() clears the model and stops the wwd."""
+def test_unload_clears_sessions_and_stops() -> None:
+    """Test that unload() clears the sessions and stops the wwd."""
     config = Config()
     wwd = WakeWordDetector(config)
-    wwd._model = MagicMock()
+    wwd._ww_sess = MagicMock()
     wwd._running = True
 
     wwd.unload()
 
-    assert wwd._model is None
+    assert wwd._ww_sess is None
     assert wwd._running is False
 
 
@@ -294,9 +289,16 @@ def test_detect_loop_queue_empty_then_sentinel() -> None:
     config = Config()
     wwd = WakeWordDetector(config)
     wwd._running = True
-    wwd._model = MagicMock()
-    wwd._model.predict = MagicMock(return_value=None)
-    wwd._model.prediction_buffer = {"hey_jarvis": [0.3]}  # Below threshold
+
+    mock_ww_sess = MagicMock()
+    mock_input = MagicMock()
+    mock_input.name = "input"
+    mock_ww_sess.get_inputs.return_value = [mock_input]
+    mock_ww_sess.run.return_value = [[[0.3]]]
+
+    wwd._ww_sess = mock_ww_sess
+    wwd._preprocessor = MagicMock()
+    wwd._preprocessor.get_features.return_value = np.zeros((1, 16, 96), dtype=np.float32)
 
     # Put one item then sentinel - the queue timeout (line 321-322) fires
     # before the item is consumed because get(timeout=0.2) blocks briefly
@@ -306,15 +308,15 @@ def test_detect_loop_queue_empty_then_sentinel() -> None:
     wwd._detect_loop()
 
     # If we get here, the loop exited cleanly
-    wwd._model.predict.assert_called()
+    wwd._ww_sess.run.assert_called()
 
 
 def test_detect_loop_no_model_continues() -> None:
-    """Test that _detect_loop continues when model is None (line 329)."""
+    """Test that _detect_loop continues when _ww_sess is None."""
     config = Config()
     wwd = WakeWordDetector(config)
     wwd._running = True
-    wwd._model = None
+    wwd._ww_sess = None
 
     wwd._audio_queue.put(np.ones(1280, dtype=np.float32))
     wwd._audio_queue.put(None)  # sentinel
@@ -324,14 +326,20 @@ def test_detect_loop_no_model_continues() -> None:
 
 
 def test_detect_loop_prediction_error_handling() -> None:
-    """Test that _detect_loop handles prediction errors gracefully (line 347-348)."""
+    """Test that _detect_loop handles prediction errors gracefully."""
     config = Config()
     wwd = WakeWordDetector(config)
     wwd._running = True
 
-    mock_model = MagicMock()
-    mock_model.predict.side_effect = RuntimeError("prediction failed")
-    wwd._model = mock_model
+    mock_ww_sess = MagicMock()
+    mock_input = MagicMock()
+    mock_input.name = "input"
+    mock_ww_sess.get_inputs.return_value = [mock_input]
+    mock_ww_sess.run.side_effect = RuntimeError("prediction failed")
+
+    wwd._ww_sess = mock_ww_sess
+    wwd._preprocessor = MagicMock()
+    wwd._preprocessor.get_features.return_value = np.zeros((1, 16, 96), dtype=np.float32)
 
     wwd._audio_queue.put(np.ones(1280, dtype=np.float32))
     wwd._audio_queue.put(None)  # sentinel
diff --git a/tests/utils/test_config.py b/tests/utils/test_config.py
index c66cc66..2376863 100644
--- a/tests/utils/test_config.py
+++ b/tests/utils/test_config.py
@@ -105,7 +105,6 @@ def test_wake_config_defaults() -> None:
     assert math.isclose(wake.cooldown_seconds, 2.0)
     assert wake.download_root is None
     assert wake.noise_suppression is False
-    assert math.isclose(wake.vad_threshold, 0.6)
 
 
 def test_wake_config_download_path_default() -> None:
diff --git a/uv.lock b/uv.lock
index 9247ea6..169b074 100644
--- a/uv.lock
+++ b/uv.lock
@@ -133,7 +133,7 @@ requires-dist = [
     { name = "loguru", specifier = ">=0.7.0" },
     { name = "numba", specifier = ">=0.57.0" },
     { name = "numpy", specifier = ">=1.24.0" },
-    { name = "onnxruntime", specifier = ">=1.16.0" },
+    { name = "onnxruntime", specifier = ">=1.18.0" },
     { name = "openai-whisper", git = "https://github.com/openai/whisper.git" },
     { name = "openwakeword", specifier = ">=0.1.0" },
     { name = "piper-tts", specifier = ">=1.4.1" },