Week 4 Dev Challenge`

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine

PHANTOM OS — A Haunted AI Computer That Remembers Its Ghosts

What I Built

What if your computer could remember every error, every failed build, and every mysterious bug — and then tell you what went wrong?

Meet PHANTOM OS, a haunted AI-powered computer that turns technical failures into paranormal investigations.

Inspired by the Ghost in the Machine theme, I built an interactive desktop-style experience where developers can summon an AI ghost to investigate system incidents, explain errors, and preserve technical memories.

PHANTOM OS brings together a few core features:

• Haunted Terminal: An interactive terminal simulator with commands to interact with the system's ghost.
• Ghost Investigator: Ask the AI to analyze an incident and explain what might have gone wrong.
• Incident Archive: Store and revisit past errors, build failures, and debugging incidents.
• Ghost Memory: Search through previously recorded incidents and retrieve forgotten technical details.
• Local AI Intelligence: Run an open-weight language model locally instead of depending on a paid cloud AI API.

The idea was to create something that feels like a haunted operating system while demonstrating a practical application of private, locally running AI.

Demo

The demo showcases the PHANTOM OS interface and its haunted-computer experience.

Try it yourself: Run the project locally using the instructions in the GitHub repository.

Code

GitHub Repository: https://github.com/rohit060321/phantomos.git

The project is organized into two main parts:

• frontend/ — React + Vite interface.
• backend/ — FastAPI application, SQLite storage, and local AI integration.

The repository also includes setup instructions, architecture documentation, and backend API tests.

How I Built It

I built PHANTOM OS using an open-source-first architecture.

Tech stack:

• Frontend: React, Vite, CSS
• Backend: Python, FastAPI
• Database: SQLite
• AI Runtime: Ollama
• AI Model: Qwen 2.5 3B (open-weight)
• Testing: Pytest

The AI runs locally through Ollama. When a user submits an incident or asks the ghost a question, the backend sends the relevant context to the locally running model and returns its response.

SQLite stores incident records, allowing users to revisit and search their previous technical experiences.

I also made a conscious decision to keep the terminal safe: it simulates commands instead of executing arbitrary operating-system commands. The AI has no shell access or unrestricted system-control permissions.

The overall architecture is simple:

1. React provides the haunted desktop experience.
2. FastAPI handles API requests and application logic.
3. SQLite stores incidents and memories.
4. Ollama runs the language model locally.
5. Qwen 2.5 3B generates explanations and responses based on incident context.

Why Does Open Innovation Matter?

For PHANTOM OS, open innovation is not just a technology choice. It is what makes the project possible.

Using an open-weight model with local inference means:

• Privacy: Incident information can remain on the user's machine instead of being sent to a third-party AI service.
• Local inference: Once the model and dependencies are installed, the application can work without depending on a cloud AI API.
• No API lock-in: The model can be replaced with another compatible Ollama model.
• Accessibility: Developers can experiment with AI without requiring paid API credits for every request.
• Transparency and control: Developers can inspect the architecture and decide how their AI system processes information.

A closed API could provide similar text-generation functionality, but local, open-weight inference gives developers more control over the model, data flow, and deployment environment.

That is the spirit of open innovation I wanted to demonstrate.

My Agent Session

The project was developed through an iterative build process, including architecture planning, implementation, debugging, and testing.

The backend currently has automated API tests covering health checks, demo incident creation, event retrieval, input validation, and memory search.

(Add your DevRelay agent session link here if you recorded one.)

The Spirit of It

Every developer has encountered that one bug that appears at 2 AM, disappears when you try to reproduce it, and returns just when you think everything is fixed.

I wanted to give that experience a personality.

In PHANTOM OS, errors are not just logs. They are unexplained incidents, and the AI is the ghost investigator trying to uncover what happened.

The project is playful on the surface, but the underlying idea is serious: AI should be something developers can run, inspect, customize, and control — not just something they rent through an API.

Sometimes the machine remembers what we forget.

And sometimes, it has a ghost.

Prize Categories

(Select the partner categories that PHANTOM OS actually qualifies for according to the challenge rules. Add the relevant partner names here.)

Thanks to the Hacktoberfest community and everyone building in the open-source AI ecosystem. Building PHANTOM OS was a fun opportunity to explore what local AI can do beyond the usual chatbot experience.