DEV Community: Jayking♟️

GHOSTTRACE: Every System Leaves a Ghost (Dia de los Muertos)👻

Jayking♟️ — Sat, 31 Oct 2026 02:32:45 +0000

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).

What I Built

A system fails. Someone fixes it. The alerts disappear, the machines start running again, and the incident becomes another forgotten record.

But the most important part of that failure might not be the component that broke. It might be the invisible chain of dependencies that allowed one problem to affect everything around it.

That thought became GHOSTTRACE: The Infrastructure Afterlife.

GHOSTTRACE is a forensic AI laboratory that investigates forgotten infrastructure incidents, reconstructs their possible consequences, and preserves the evidence behind them.

I wanted to build something different from a chatbot that simply reads a report and gives you a summary. With GHOSTTRACE, the report becomes an investigation you can actually explore.

The experience combines four ideas:

The Evidence Lens: An open-weight AI model searches incident reports for relevant passages and ranks them by semantic similarity. Users can inspect the source evidence rather than relying entirely on a generated explanation.

AI Reconstruction: Claude interprets the report and retrieved evidence, identifying systems, possible dependencies, event sequences, and questions the available information cannot answer.

The Infrastructure Afterlife: A visual network reveals how systems connect. Users can explore hypothetical failure paths and experiment with containment strategies.

The Memory Vigil: Inspired by Día de los Muertos, visitors can light symbolic lanterns to preserve documented traces and lessons that might otherwise be forgotten.

The application also supports saved investigations and Markdown evidence dossiers.

The included incident archives are fictional. GHOSTTRACE demonstrates a method for exploring evidence, not a system that certifies historical events or predicts real disasters.

What began as a Halloween concept gradually became a bigger question: What if software could help us remember not only what failed, but what the failure taught us?

Demo

Live application:

https://ghosttrace-six.vercel.app/

The best way to explore GHOSTTRACE is through its investigation workflow.

Start with The Bellwether Incident, one of the included fictional archives.

Open the Evidence Lens and watch the open-weight model retrieve passages relevant to the investigation. Inspect the ranked evidence before moving to the reconstruction.

Next, select Reconstruct with Claude to generate a structured interpretation of the incident.

Explore the resulting dependency network, examine the supporting passages, and investigate the possible consequences of the disruption.

Then visit the Memory Vigil.

Light a lantern for a documented system trace and see how the evidence becomes part of a preserved remembrance record.

That final transition, from an overlooked passage in a report to an illuminated trace in the archive, is the experience I wanted to create.

Code

Source repository:

https://github.com/paulos-ui/ghosttrace

GHOSTTRACE is a standalone, MIT-licensed project developed for the Week 4 challenge.

The repository includes the application, open-weight evidence retrieval, Claude reconstruction endpoint, source verification logic, deterministic graph simulation engine, tests, and technical documentation.

The core implementation is available for inspection and extension.

How I Built It

The biggest technical decision was separating finding evidence from interpreting evidence.

Those are related tasks, but they should not be treated as the same thing.

Open-weight AI comes first

I used the Apache-2.0 licensed "Xenova/all-MiniLM-L6-v2" model with Transformers.js to build the Evidence Lens.

The model runs directly in the browser.

It converts report passages and search queries into numerical embeddings, then compares them using cosine similarity to identify semantically relevant passages.

This means evidence discovery does not require a paid inference API or a Claude connection.

The model downloads on first use, and subsequent embedding calculations run locally in the browser.

Users can inspect the retrieved passages and their relevance scores before requesting any further analysis.

This is the open-weight foundation of GHOSTTRACE. Without it, the product would lose its independently usable evidence investigation capability.

Claude provides optional structured interpretation

Once the relevant passages have been identified, users can explicitly request a reconstruction.

The Next.js backend sends the report and selected evidence to the Anthropic Messages API.

Claude extracts possible infrastructure components, directed relationships, chronological events, and unresolved questions.

I chose Claude for this interpretation layer, but Claude is proprietary. It is not the open-source component of the project.

Keeping the retrieval and interpretation stages separate means the evidence investigation remains useful even without the hosted model.

Evidence should be checked, not blindly trusted

This was one of the most important engineering considerations.

An AI-generated explanation can sound convincing even when the supporting evidence is weak.

GHOSTTRACE checks claimed quotations against the supplied report and flags quotations that cannot be matched.

A matching quotation does not prove that an inferred relationship is correct. It only confirms that the quoted text exists in the source.

That distinction matters.

A useful investigation tool should make uncertainty visible instead of hiding it behind confident language.

Turning analysis into an interactive investigation

I built the interface with Next.js, React, TypeScript, and custom CSS.

A directed-graph engine maps the reconstructed systems and supports hypothetical containment experiments.

Instead of treating the AI response as the finished product, the application turns it into something users can examine and question.

Saved investigations and remembrance lanterns use browser-local storage. Users can also export a Markdown dossier for reference.

During deployment, I encountered a TypeScript inference error in the graph implementation and later a Next.js dependency security warning.

Resolving those issues was a reminder that getting a prototype to look finished is very different from getting a production build to run reliably.

The application is now deployed on Vercel, with both the open-weight evidence workflow and Claude reconstruction available.

Why Does Open Innovation Matter?

Because an investigation should not become inaccessible when one proprietary service stops working.

I didn't want GHOSTTRACE's most important capability, finding and examining evidence, to depend entirely on an external AI API.

Using an open-weight model changed what I could build.

First, evidence retrieval stays under the user's control. The browser processes report text locally during the Evidence Lens workflow, without uploading that text to a separate embedding service.

Second, the underlying retrieval system is inspectable. Developers can examine the implementation, replace the embedding model, change how passages are selected, or experiment with alternative ranking approaches.

Third, the core evidence search does not require paid API calls. Someone can explore the included archives and use the local model without configuring Claude.

There are honest limitations.

The initial model download requires internet access. The complete hosted application is not an offline product, and choosing Claude reconstruction sends report content to an external API through the server.

The application makes this separation intentional.

Open innovation doesn't have to mean rejecting every proprietary tool. For me, it means ensuring that the essential capability remains accessible, understandable, and replaceable.

That is why MiniLM is part of the investigation engine rather than simply being included in the project's dependencies.

The Spirit of It
Halloween gave me the visual direction. Día de los Muertos gave the project its deeper purpose.

I began with the idea of a haunted machine, something that appears silent but still contains traces of what happened inside it.

The interface uses the atmosphere of a dark technical archive, where forgotten incidents are uncovered through fragments, connections, and reconstructed timelines.

But I didn't want the spooky elements to be decoration alone.

That led to the Memory Vigil.

Inspired by the spirit of remembrance associated with Día de los Muertos, it provides a symbolic space for preserving the records and lessons that investigations uncover.

Each lantern is tied to a documented trace rather than invented historical testimony.

The feature is not meant to equate machines with people or recreate personal memories. It is a small reflection on how easily important knowledge can disappear once something stops demanding our attention.

For me, the most meaningful moment happens after the investigation.

You have explored the report, examined the possible chain of failures, and reached the end of the analysis.

Then you light a lantern.

A piece of evidence that began as an overlooked line in a report becomes something deliberately preserved.

That is the idea behind GHOSTTRACE.

The ghost isn't something supernatural hiding in the system. It is the trace of what happened, waiting to be understood.

And sometimes, understanding the past is the best place to begin building something more resilient.

GHOSTTRACE. Every system leaves a ghost.

GHOSTTRACE: Every System Leaves a Ghost 👻

Jayking♟️ — Sat, 31 Oct 2026 02:19:18 +0000

Some failures disappear from memory the moment the system starts working again. The equipment gets repaired, the alerts stop, and the incident becomes another entry in an archive.

But what if the most important part of that incident was never the failed component? What if it was the chain of dependencies nobody fully understood?

That question inspired me to build GHOSTTRACE, an open-weight AI investigation laboratory designed to recover the hidden stories behind infrastructure failures.

What I Built

GHOSTTRACE transforms written incident reports into interactive investigations.

Instead of presenting users with another AI chatbot, I wanted to create an environment where evidence could be discovered, interpreted, questioned and preserved.

The application lets users explore incident archives, identify relevant evidence, reconstruct potential system dependencies and examine how disruptions might have spread.

I also introduced Memory Vigil, a remembrance experience inspired by Día de los Muertos. Visitors can light symbolic lanterns for documented traces, preserving the lessons that might otherwise disappear with time.

The included fictional incidents provide a safe way to explore the experience without presenting invented events as historical facts.

Demo

Live application: https://ghosttrace-six.vercel.app/

To experience GHOSTTRACE, open an incident archive, run the Evidence Lens, reconstruct the report with Claude, inspect the resulting network and visit the Memory Vigil.

Code

GitHub: https://github.com/paulos-ui/ghosttrace

The repository contains the application source, evidence-processing logic, reconstruction pipeline, graph engine and documentation.

How I Built It

GHOSTTRACE combines two different approaches to AI.

The first is an open-weight evidence model. Using Transformers.js and the Apache-2.0 licensed MiniLM model, the application generates embeddings directly in the browser.

These embeddings help identify relevant passages from the original report. Users can inspect the retrieved evidence and its relevance scores before any further reconstruction takes place.

The second component uses the Claude API for structured interpretation. Claude helps extract systems, possible dependencies, event sequences and unresolved questions.

Claude is proprietary, and I intentionally keep that distinction clear. The open-weight evidence retrieval works independently of Claude, while the hosted model provides optional structured analysis.

The reconstructed results can be explored through an interactive network. A deterministic graph engine supports hypothetical containment experiments, while evidence quotation checks help distinguish text found in the report from uncertain interpretations.

The interface is built with Next.js, React and TypeScript and deployed on Vercel.

Why Open Innovation Matters

For me, the most important decision was making evidence retrieval open and inspectable.

A closed AI service can generate a convincing explanation, but that explanation becomes much more useful when users can see which passages informed the investigation.

With MiniLM running in the browser, evidence retrieval does not require a proprietary inference API key. After the model is downloaded, the embedding calculations happen locally.

That also means developers can inspect the implementation, experiment with alternative models and change how evidence is retrieved.

The approach has limitations. Initial model downloads require internet access, and choosing Claude reconstruction sends report content to a hosted API. GHOSTTRACE makes those distinctions explicit rather than claiming that the entire application runs offline.

Open innovation matters here because the evidence-discovery layer can remain independently useful, transparent and replaceable.

The Spirit of It

I interpreted Ghost in the Machine in two ways.

For Halloween, GHOSTTRACE presents forgotten incidents through the atmosphere of a haunted technical archive. A failed system becomes a mystery, and the remaining evidence becomes the trail that leads us through it.

For Día de los Muertos, I wanted to explore remembrance more thoughtfully.

The Memory Vigil gives documented traces a place to remain visible through symbolic lanterns and evidence excerpts.

It does not pretend to resurrect people, recreate memories or invent historical testimony.

It preserves what the available evidence can actually tell us.

What I Learned

The hardest part was not designing a spooky interface. It was deciding how to prevent an impressive-looking reconstruction from becoming more convincing than its evidence.

Two events occurring close together do not automatically prove one caused the other.

That distinction shaped the application. Evidence ranking, AI interpretation, quotation verification and deterministic simulations remain separate parts of the experience.

GHOSTTRACE is not a certified disaster-prediction system. It is a working exploration tool built to make forgotten dependencies easier to investigate and understand.

The project reminded me that good AI development is not only about generating answers. Sometimes it is about making uncertainty visible and preserving the evidence worth remembering.

GHOSTTRACE. Every system leaves a ghost.

devchallenge #hf26challenge