This is a submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine
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
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:
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. 🎃🌼