The 404 Wasn't the End. I Built an AI Investigator for the Internet's Ghosts.

Hacktoberfest Open-Source AI Challenge: Ghost in the Machine Submission 👻🌼

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

Maybe the page moved. Maybe the project was abandoned. Maybe someone deleted years of useful explanations without leaving a forwarding address.

But what if the page isn't completely gone?

What if a copy is still hiding somewhere in the history of the internet?

Afterlink is an AI-powered documentation investigation tool. It searches for historical versions of broken or changed documentation links, retrieves archived content, and uses AI to help investigate what those pages contained.

I interpreted Ghost in the Machine as the forgotten parts of the internet: documentation that disappears, tutorials that become inaccessible, and technical knowledge that survives only in old snapshots.

I wanted to build something that could investigate those digital traces rather than simply announce that a link was broken.

The important part is what Afterlink doesn't do.

It doesn't silently replace your broken link.

It doesn't pretend that an AI-generated answer is historical truth.

It doesn't commit changes to your repository.

Instead, it gives you evidence and lets you decide what should be recovered.

Afterlink doesn't resurrect documentation by guessing. It investigates what the archive remembers.

That is my interpretation of the Ghost in the Machine theme: the "ghost" is forgotten documentation still haunting the links inside today's codebase.

The key design decision: AI must investigate evidence, not invent history.

A model can produce a convincing explanation of a missing page without actually knowing what it contained. Afterlink validates recommendation URLs and evidence excerpts against the supplied archive information before displaying them.

It also preserves the distinction between an unavailable page, an archived page, and a conclusion supported by historical evidence.

Try Afterlink: https://afterlink-sigma.vercel.app/

Source code: https://github.com/shrutikotgire0129/afterlink

The application is deployed on Vercel. You can load the sample project and run an investigation without installing Ollama.

Repository: https://github.com/shrutikotgire0129/afterlink

Document | v Link Extraction | v Link Availability Checks | v Internet Archive CDX Search | v Archived Page Retrieval | v Content Extraction | v AI Investigation | v Evidence Validation | v Original / Archive Comparison | v Investigation Report Enter fullscreen mode Exit fullscreen mode Each stage has its own API route. That separation makes it easier to validate inputs, handle failures, and prevent an error in one stage from silently becoming an incorrect investigation result.

I wanted Afterlink to support local AI inference rather than depend entirely on a hosted model.

The application communicates with Ollama through its local API:

http://localhost:11434/api/chat Enter fullscreen mode Exit fullscreen mode This made it possible to develop and run the AI investigation workflow on my own machine without requiring a paid hosted AI API for local inference.

I also wanted anyone to be able to try Afterlink without installing a model locally.

The deployed Vercel application therefore uses Groq with the open-weight openai/gpt-oss-20b model.

The provider is selected server-side based on the execution environment. The Groq API key is stored as a server-side environment variable.

I tested an important deployment scenario: I stopped Ollama on my computer and ran the complete AI investigation workflow on the deployed Vercel application. It continued working.

The production application does not depend on my computer being switched on.

An AI model can return a plausible archive recommendation that doesn't actually match the historical capture supplied to it.

During development, I encountered an issue where matching candidates using only the original page URL was insufficient when multiple archive snapshots existed.

I tightened the matching logic so that both the original candidate URL and the exact archive URL must match.

I also added validation for evidence excerpts. An excerpt must be present in the supplied archived content; the model cannot simply invent a quotation and present it as evidence.

I deliberately prefer an uncertain result over an unsupported conclusion.

The result is intended to be useful beyond a single AI response.

The open part of Afterlink changes how the investigation system can be run and adapted.

Local inference: Gemma 3 1B can run through Ollama on a developer's own machine. Local analysis doesn't require sending the AI prompt to a hosted model provider.

Model flexibility: The investigation workflow is separated from the model provider. I can use Gemma locally and a different open-weight model in production without redesigning the entire application.

Control and experimentation: Running an open-weight model locally makes it possible to inspect its behavior, change prompts, test limitations, and improve evidence validation around its actual outputs.

Accessibility: A small model makes local experimentation possible on modest hardware, although inference speed and available memory still depend on the machine.

There is an important limitation: retrieving historical pages still requires internet access, and the public Vercel demo uses hosted inference. Afterlink is not an entirely offline archive crawler.

For me, open innovation made the project more flexible: I could develop locally, experiment with an open-weight model, and make the application accessible through a hosted deployment.

A 404 page is a strange kind of disappearance.

The address is still there. The link is still in someone's notes, tutorial, or README. But the information behind it has vanished.

Maybe it contains the explanation someone needs. Maybe it only contains part of the page. Maybe it provides no useful evidence at all.

Afterlink cannot bring every missing page back. It can, however, investigate what remains and make that evidence easier to understand.

The internet forgets. The archive remembers. Afterlink investigates.

The biggest lesson from building Afterlink was that AI is often most useful when it is not allowed to do everything.

The strongest parts of the application are the boundaries around the model:

Code handles the parts that should be predictable.

That separation made the project much more reliable.

But the code that depended on that documentation can survive for years.

So I built Afterlink around one question:

When the documentation is gone, what evidence is still alive?

The docs disappeared. The code remembered. Afterlink goes looking for what remains.

Thank you for taking a look at Afterlink — and happy Hacktoberfest. 👻