👻 PhantomOps: The AI Exorcist That Works With the Internet Off | Ghost in the Machine Submission 🎃🌼

A developer built PhantomOps, an open-source "FinOps & kernel agent" that runs entirely offline to detect zombie and runaway processes on Windows and cloud-cost anomalies, using a local TabPFN classifier plus Gemma 2 2B via Ollama for process autopsies. The tool requires human approval through Auth0 step-up OAuth2 before terminating processes and issues SHA-256 receipts, with the core scan-detect-autopsy-kill loop running with the internet disconnected at zero inference cost. It was submitted to the Hacktoberfest Open-Source AI Challenge's "Ghost in the Machine" week.

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 Open Task Manager right now. Scroll slowly. Somewhere in that list is a process with no reason to exist — a stale worker from a project you closed in June, a leaky helper quietly eating 400 MB, a script that was supposed to finish an hour ago and never got the memo. Your machine is haunted. PhantomOps is the exorcist. 👻 PhantomOps is a zero-cloud-leakage FinOps & kernel agent that runs entirely on your own hardware. It finds the ghost resources haunting your Windows kernel or your cloud bill, runs a local AI autopsy on them, lets you interrogate them in a live voice séance, requires a human to sign the kill order through Auth0 — and then banishes them for real, with a cryptographic receipt and a synthesized exorcism scream. How I interpreted the theme: literally. Zombie processes are the undead of software — programs that finished their purpose but refused to leave memory. And Día de los Muertos teaches that the dead deserve to be honored properly, not just discarded. So PhantomOps doesn't just kill -9 a ghost. It gives it a funeral: .safetensors on disk, CPU-only scores every process zero-shot for how "haunted" it is And because this is the open-source AI challenge: the core loop — scan → detect → autopsy → kill — runs with the internet unplugged. The model weights sit on your disk. Your process inventory never leaves the chassis. The AI inference bill is $0.00 , forever. A few receipts from my own testing: spawn zombie.py — it allocates an actual explorer.exe , svchost.exe , code.exe , ollama.exe … and a self-preservation rule mean it only kills what it can prove is a ghost. ▶️️ Watch the full exorcism ritual: 🔗 Direct link: Watch on YouTube https://youtu.be/H0Jv7wWqIi4 What the recording shows — the 90-second arc: python spawn zombie.py — a real 700 MB zombie process comes alive on my machine Zero-cloud-leakage FinOps & kernel agent. Find the ghosts haunting your Windows kernel or your cloud bill → run a local AI autopsy → interrogate them in a live voice séance → get human clearance through Auth0 → put them to rest with a signed cryptographic receipt and a synthetic exorcism scream. Built for the Hacktoberfest Open-Source AI Challenge: Ghost in the Machine 🎃🌼 Every machine has ghosts. The staging server that nobody killed in March. The script that leaked memory for 400 hours while everyone went home. The GPU instance cryptojacking at 3 AM. They drain your RAM and your budget — invisible, unaccounted for, undead . PhantomOps is a paranormal investigator for your infrastructure: it sees them, names them, questions them, and with a human's blessing banishes them — entirely on your own hardware . The full architecture is documented in the README. Where to start digging: | File | What's Inside | |---|---| | spawn zombie.py | 🧟 The demo prop — summons a real 700 MB runaway process | | app.py | 🎛️ The Streamlit haunted console — 3 tabs, KPIs, Auth0 callback handler | | src/live scanner.py | 🖥️ Per-PID kernel snapshot tab-level precision + process-tree exorcist | | src/detector.py | 🔮 TabPFN classifier + regressor + counterfactual blame engine | | src/reasoner.py | 🧠 Gemma 2 autopsies & séance roleplay Pydantic-enforced JSON | | src/gatekeeper.py | 🔐 Auth0 step-up OAuth2 + JWT decode + SHA-256 receipts | | src/narrator.py | 🎙️ ElevenLabs STT / dual-voice TTS / exorcism SFX | The stack: Python · Streamlit + Plotly dark telemetry UI · tabpfn Prior Labs · Gemma 2 2B via Ollama · Auth0 OAuth2 · ElevenLabs scribe v1 , multilingual v2 , Text-to-Sound-Effects · psutil · PyTorch on CPU. 🖥️ LIVE KERNEL psutil ☁️ CLOUD ESTATE CSV └────────────┬────────────┘ ▼ 🔮 TABPFN-3.5-FAST local .safetensors, CPU classifier → ghost confidence · regressor → doomsday counterfactuals → feature blame ▼ flagged ghosts only 🧠 GEMMA 2 2B via OLLAMA local JSON autopsy + first-person séance roleplay ▼ 🔐 AUTH0 STEP-UP 🎙️ ELEVENLABS human clearance STT + 2-voice TTS SHA-256 receipts + exorcism SFX ▼ 💀 EXORCISM: tree-kill + taskkill /F /T /PID 📜 signed receipt: operator ∥ resource ∥ command ∥ time Stage 1 — Ingestion, with per-tab precision. psutil.process iter walks the entire Windows process table and builds one evidence file per PID: RAM, CPU, threads, uptime, command line, and an estimated hourly cost mem mb×0.0008 + cpu%×0.015 + threads×0.004 . Because Chromium runs each active tab as its own renderer process, the scanner naturally sees each tab as its own suspect — a runaway tab can't hide behind its browser. A cmdline fingerprint flags any running spawn zombie.py as an unmistakable zombie runaway script ; heuristics catch the rest live memory hog 4% RAM, live cpu runaway 50% CPU, thread bloated daemon 85 threads . Stage 2 — TabPFN does the divining. The classifier fits on baseline telemetry signatures and scores the remaining estate zero-shot — no gradient training, no GPU, no data upload. My favorite seven lines in the repo: Ensure any active spawn zombie.py is always surfaced at the very top zombie mask = df "resource id" .str.contains "spawn zombie", case=False, na=False if zombie mask.any : df.loc zombie mask, "ghost confidence" = 0.9999 When the scanner sees the demo zombie, there is no "maybe". It is 99.99% sure , and the queue agrees. A TabPFNRegressor then simulates 30 days of decay memory +1.35%/day to chart the cumulative financial drain against the flat $0 line after exorcism — and estimates time-to-OOM-crash in hours. Counterfactual sliders let you mutate a ghost's telemetry live and watch TabPFN re-classify it as healthy: the moment the confidence drops is the explanation of what was haunting it. Stage 3 — Gemma 2 performs the autopsy. Flagged telemetry goes to a local Gemma 2 2B through Ollama, which must return JSON matching a Pydantic GhostAutopsy schema — incident title , severity , root cause autopsy , monthly waste usd , and an environment-aware exorcism command taskkill /F /T /PID <pid for kernel ghosts, aws ec2 terminate-instances for cloud spirits . The same model then switches personas for the séance: first person, dramatic, technically accurate to its own real metrics . Ask it "why are you hogging memory?" and it answers as a trapped process begging for either a fix or the exorcism. Stage 4 — Auth0 holds the ward. Destructive actions generate an OAuth2 authorization URL with prompt=login explicit human re-authentication and a SHA-256 state binding the request to the exact resource + command — so a callback can't be replayed against a different target. On approval, the JWT is decoded in-process and a tamper-evident receipt is minted: 📜 EXOR-7F3A21C9D4 operator : auth0|verified-operator command : taskkill /F /T /PID 4132 binding : SHA-256 operator ∥ resource ∥ command ∥ timestamp The AI agent literally cannot kill a process without a living human signing off through Auth0. That's the human-in-the-loop pattern, enforced cryptographically. Stage 5 — ElevenLabs is the medium. Three distinct APIs, two personas: scribe v1 transcribes your spoken séance questions, multilingual v2 speaks on both sides of the veil an authoritative Commander for incident briefings, the hoarse Callum for the dying process , and Text-to-Sound-Effects synthesizes the exorcism — "a sci-fi server rack power down with a ghostly digital whoosh and electrical discharge" — the instant a ghost dies. Audio is cached locally to conserve credits. Stage 6 — The exorcist kills carefully. Children die first, then psutil.kill , then a native taskkill /F /T /PID to clean up handles, then .venv parent launchers. It refuses to harm its own Streamlit process or anything on the protected list — unless the target is explicitly the zombie. Professional liability standards, paranormal cleanup division. Everything persists across sessions: autopsies, exorcism records, and audit receipts survive restarts via a local JSON/CSV state layer. For PhantomOps, open weights aren't an ideology — they're the architecture . gemma2:2b for any Ollama model in one env var. Load different TabPFN weights. Rewrite the ghost's séance persona to be funnier, darker, or multilingual. A closed ghost-hunter is a black box that can vanish, reprice, or silently swap its model under you — an open one is a The ghost stays in your machine. So does the exorcist. The first time it worked, I actually got chills. I had spawned a zombie — 700 MB of real RAM, burning real CPU — and asked it, out loud, through my microphone, why it was still alive. ElevenLabs transcribed me. Gemma answered as the dying process, in first person, citing its own actual memory footprint. A hoarse, haunted voice read the reply back across the quiet room. Then I clicked the kill button, logged in through Auth0 like a proper executioner, and watched the PID vanish from psutil in real time. The exorcism SFX — that ghostly server-rack power-down — played, and the machine felt different . Lighter. Quiet in the way a house is quiet after a storm passes. Here's the thing about Día de los Muertos: it isn't about banishing the dead. It's about remembering them properly . So every ghost in PhantomOps gets the full rite — an autopsy cause of death , a séance last words , a signed receipt a memorial plaque in the audit ledger , and a sound the tolling of a dying server . Some marigolds for my RAM. 🌼 Somewhere in your Task Manager is a process that should have died months ago. Now there's a proper way to say goodbye. TabPFN is the brain of the entire pipeline — and the deepest integration in the project. TabPFNClassifier performs zero-shot ghost scoring on live kernel telemetry no training loop, no GPU, offline .safetensors weights with TABPFN OFFLINE=1 ; TabPFNRegressor powers the 30-day "Doomsday" cost forecaster and time-to-OOM estimation; and a counterfactual simulator uses TabPFN's predictions for real-time what-if sliders and zero-shot, perturbation-based feature blame attribution. A local Gemma 2 2B via Ollama does all reasoning on-device: Pydantic-schema-enforced JSON autopsies with severity, dollar drain and exact remediation commands — plus the first-person séance roleplay where the haunted process speaks for itself using its own real metrics. Fully local, swap-friendly, works offline. PhantomOps is an AI agent that takes destructive actions on a real OS — so it doesn't get to act alone. Auth0 enforces human-in-the-loop step-up authorization prompt=login for every exorcism, cryptographically binds each approval to the exact resource and kill command via a SHA-256 state , decodes the JWT claims in-process, and mints tamper-evident SHA-256 execution receipts that persist in the audit ledger. Three ElevenLabs APIs form the voice layer: scribe v1 speech-to-text transcribes your spoken séance questions, multilingual v2 TTS performs both sides of the ritual with two distinct personas the authoritative Commander and the haunted Callum voice of the dying process , and Text-to-Sound-Effects generates the exorcism power-down that plays the moment a ghost is banished. 👻 Your turn: open Task Manager and find the weirdest "process that shouldn't exist" on your machine — drop it in the comments. Best haunted process name gets featured in the README's Hall of Ghosts. Built in one haunted week for Hacktoberfest. MIT licensed. The ghost stays in your machine. 🎃🌼