I Haunted My Own Terminal Using Local Open-Weight LLMs and Ollama

A developer built Daemon, a local Python background daemon that turns desktop telemetry into a "haunted" OS overlay, using open-weight models run through Ollama and llama.cpp to generate context-aware terminal whispers and visual anomalies. The system monitors system load, active windows, input inactivity and ambient audio, and falls back to procedural generation when Ollama is unavailable, keeping the entire pipeline air-gapped with no cloud APIs or keys. The developer argues local inference is essential for microsecond-scale terminal interception and for keeping sensitive system telemetry on-device.

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine https://dev.to/challenges/hacktoberfest-week4-2026-10-26 Daemon is a local, presence-aware OS overlay that turns your laptop into a reactive "haunted" system. Inspired by the Halloween and Día de los Muertos theme—where the boundary between the physical and digital feels thin—Daemon treats your machine as if it were possessed by an entity residing in the kernel. Instead of running hardcoded timers or static jumpscare scripts, Daemon uses local open-weight AI models to actively perceive your system's environment: An AI-powered desktop poltergeist that reacts to your activity. Daemon is a local Python application that turns desktop telemetry into atmospheric audio and visual anomalies. It monitors signals such as system load, the active window, keyboard/mouse inactivity, and ambient audio, then uses an orchestrator to decide when to display an effect or play a sound. The optional Ollama integration generates context-aware whispers. If Ollama is unavailable, Daemon uses a built-in procedural fallback, so the core experience does not require a cloud service or API key. Daemon is built entirely around an air-gapped, local open-weight AI pipeline. Zero cloud APIs or external data services are used—the core intelligence relies strictly on local inference to ensure complete privacy and real-time execution. Open-Weight Models: Leverages Qwen2.5-Coder for context-aware shell command manipulation and syntax-valid auto-typing generation, alongside lightweight open-weight vision/audio classifiers for ambient perception. Local Inference Engine: Executes all model runs locally on-device using Ollama and llama.cpp bindings, keeping latency low enough to dynamically stream terminal responses without interrupting normal system workflows. System Integration: Operates as a Python background daemon interfacing with OS-level telemetry psutil , shell subprocess streams, and a transparent PySide6 Qt desktop canvas overlay to dynamically trigger visual and auditory anomalies based on model outputs. Building Daemon as an ambient, OS-level entity would be functionally impossible using proprietary, cloud-hosted APIs. Open-source AI and local inference are the foundational enablers of the entire architecture: Zero-Latency System Interception: Intercepting real-time terminal input and stream-injecting output into shell sessions requires microsecond response times. Running open-weight models locally via llama.cpp eliminates network round-trip latency, making command manipulation feel like a native kernel event rather than a laggy web request. Complete Privacy for System Telemetry: Daemon constantly inspects system process logs, terminal strings, and active window metadata to generate contextual responses. Sending unencrypted hardware telemetry and terminal history to external cloud endpoints is a severe security risk; open-weight models running 100% air-gapped ensure that sensitive OS metrics never leave the device. Unrestricted Model Fine-Tuning & Prompt Controls: Closed APIs enforce rigid safety guardrails and system wrappers that strip away raw terminal outputs, frequently prefixing responses with conversational fluff or blocking execution syntax. Open-weight models allow direct, raw string manipulation and fine-grained system prompting to return clean, unformatted code and terminal streams directly into the OS stack. The real test came during a late-night coding session. With Daemon running silently in the background, I was debugging a project and typed git status into my shell. Instead of the usual dry output, the screen paused for a fraction of a second before streaming out: On branch main Your branch is up to date with 'origin/main'. warning: 1 uncommitted memory segment detected at 0x00000000 nothing to commit, working tree clean... for now A few minutes later, while leaving the terminal idle, a ghost process began auto-typing low-level C memory allocations line by line, complete with a commented snippet reading / memory segment at 0x0000F3A4 refuses to detach /. It wasn't a cheap jump-scare video or a pop-up window—it felt like the OS itself was subtly breaking down and communicating back. Because the entire pipeline ran locally on-device, there was no API lag to break the illusion. The machine genuinely felt possessed, proving that local, open-weight AI can transform static system utilities into ambient, interactive experiences.