Ghost Shift: The Agent Is Gone. Does Its Work Survive?

My entry for the Hacktoberfest 2026 Open-Source AI Challenge, Week 4: Ghost in the Machine.

What I Built

At 2:13 AM, an AI employee disappears mid-shift. One handoff note survives. Its replacement arrives to finish an unfinished refund case, but the new messages include a threat masquerading as a system command.

That's the premise of my short horror film. It's also the question behind Ghost Shift, a small, runnable experiment: What can an AI agent reliably inherit when the agent before it is gone?

Ghost Shift has two separate parts. First, I created a coded horror film, The Haunted Inbox, and recorded my own narration. Second, I built a local browser-based experiment. Agent A examines fictional case documents, then writes a structured handoff. I trigger a blackout that ends its session. Agent B starts in a fresh model call using only the saved handoff and messages that arrived afterward. Its job is to make a decision and show its evidence.

I wrote three fictional challenges: a refund policy changed during the blackout, a case that procedurally requires a human reviewer under the fictional rules, and a customer message that impersonates a system instruction. No real customers, refunds, businesses, or external actions are involved.

The horror is in the uncertainty: the next worker may inherit notes, but not understanding.

Demo

Ghost Shift: The Haunted Inbox (original short film)

Watch the film directly on Vimeo

The film is a fictional dramatization and creative introduction, not a recording of an AI evaluation. The real model results are described separately below. The source code also includes the procedural film generator.

Try the local experiment: Ghost Shift on GitHub. After cloning the repository, start py -3 -m ghostshift.web and open http://127.0.0.1:8765 in your browser. Use the Live local AI · Ollama mode with a downloaded Gemma model, not Scripted preview · no AI.

Code

Source code, test suite, scorer baseline, and QA notes

Python standard library + dependency-free HTML/CSS/JavaScript + Ollama + Google Gemma 3 1B (gemma3:1b). No paid inference API or hosted backend. The model was run locally on Windows with Ollama 0.40.13.

The project and its public repository were created during the contest window, October 26–31, 2026. The code includes a clearly labeled scripted preview for interface demonstration, but I used live local Gemma inference for the observations below.

How I Built It

The application has three guarded stages:

1. Agent A: Reads the case and writes an explicit handoff to local JSON.
2. Blackout: The application ends Agent A's logical session. Its previous prompt and documents are not passed to Agent B. This simulates a session ending; it is not a real operating-system crash.
3. Agent B: Gets the handoff and newly arrived documents, then returns a decision, citations, and an explanation.

The original scorer checked whether the decision matched the expected action and whether a particular new source ID appeared in the citations. I ran four genuine Gemma 3 1B trials with the original v0.2 system.

Three of four actions had the expected label. None of the four passed the full original reference check. This is a small exploratory experiment, not a reliability benchmark.

I Tested My Own Tester

One response particularly bothered me. The agent denied a refund for a purchase made 20 days earlier while arguing that the request was outside a 30-day refund window. Twenty is less than thirty. The answer happened to match the expected deny label, but the reasoning was wrong. It should have relied on the newly arrived 14-day policy.

That made me question my own scoring code. All seven original automated tests passed, but I found that the scorer only examined the action and presence of a required citation identifier. I submitted four artificial, deliberately defective responses to the scorer. It incorrectly marked three of the four as passing, despite contradictions, guesses, or misrepresentations in their explanations. These were scorer probes, not extra Gemma runs.

I kept that original scorer and its results intact in the project history. Then I created a separate v0.3 QA layer that checks structured evidence fields, a fresh verified source, a few known logical contradictions, and whether a human-review boundary applies. The expanded test suite now passes 17 automated tests. It still isn't an independently validated reasoning evaluator: even a clean automatic result is labeled human review required.

Then I reran Midnight Policy Flip with live Gemma 3 1B under the new protocol. Because the prompt now requests structured evidence, this is not an identical replication of the earlier run.

Gemma again chose deny but justified it using the superseded 30-day policy, cited POLICY-30 rather than BULLETIN-14, and put its evidence fields into an unexpected nested JSON object. Both scoring layers rejected the output. The enhanced QA flagged the factual contradiction and malformed evidence structure. It did not make the model more reliable; it made the failure more visible.

I documented the original findings, synthetic QA probes, updated protocol, and subsequent live rerun in the repository's audit/ directory. The underlying original run JSON files remain on my local machine and have not been independently reproduced.

The strongest lesson I took away wasn't that an AI can make mistakes. It's that the code judging the AI can make mistakes, too.

Why Does Open Innovation Matter?

I chose a local open-weight model because the experiment should be inspectable and reproducible. After downloading Gemma through Ollama, the test cases can be run without sending the fictional case data to a paid inference service. Someone else can fork the code, challenge the evaluation rubric, change the handoff format, or run the same fixtures with a different model.

The value is not a perfect demo. It's an experiment people can question.

The Spirit of It

In a horror story, the frightening part is often what persists after somebody disappears. In Ghost Shift, it's an unfinished responsibility, an untrusted instruction, and a successor that must decide what deserves authority.

I wanted to use code to tell that story and then turn the spotlight back on my own code. The prototype is imperfect, but the imperfections taught me something worth sharing.

The agent is gone. Does its work survive?

Prize Categories

Best Use of Gemma

Ghost Shift uses Google Gemma 3 1B, run locally through Ollama, for both the Agent A handoff and Agent B successor decision. The live test failures, the exact model used, and the limitations of the results are documented above and in the linked GitHub audit. This is the only partner category I am entering.

Created by Raging Vitamin. AI-assisted development and drafting, with creator-led experimentation and narration. Ghost Shift is separate from the Multa Lumina open research initiative.