GHOST PROTOCOL

Inspiration

I'm Hitesh, a CS major, and my teammate Rushat is a pure math major. This is our first time doing a hackathon in college for both of us. So we began our process with what each of us are good at and searched for real problems.

While researching, we came across a website describing the issues online payment companies face when their systems fail. In a real outage, no single engineer sees everything: security sees traffic, the deployment team sees releases, and the database team sees the data layer. They disagree about the cause, and the clock is running. That led to GHOST PROTOCOL: what if AI agents, each with partial information and different priorities, had to diagnose and fix an outage by debating it, with no central boss?

What it does

GHOST PROTOCOL is a multi-agent simulation of a payments platform (gateway, auth, payments, database, cache).

We inject a fault, and each agent sees only its own slice of the telemetry.
Agents state their beliefs, challenge each other, share evidence, and vote on a fix. Their beliefs shift as new evidence arrives.
Safety-minded agents (like Database and Gateway) can veto a risky action, and when stakes are high and the evidence is ambiguous, the system asks a human.
We compare the outcome against a fixed-rule baseline on recovery time, availability, and unnecessary actions. Every decision keeps a full audit trail.

Agents reason with deterministic rules by default, with an optional LLM mode.

How we built it

A seeded, deterministic microservice simulator with fault injection, so every run is reproducible and can be replayed.
Python for the backend and agent logic, and a React, TypeScript, Tailwind CSS, and React Flow frontend for the live service graph and agent conversation.
AGNTCY for agent registration and discovery, so specialist agents can be recruited by capability.
Our strengths shaped the split: system building in Python on my side, and the math behind how agents update beliefs and weigh actions on Rushat's, using Bayes' rule, $P(h \mid e) \propto P(e \mid h)\,P(h)$.
We started with AI-assisted ("vibe") coding to move fast.

Challenges

Overcoming the hallucination issue. LLM hallucinations can spread between agents, so we kept LLMs out of decisions: agents share measured data, code decides, and a guard rejects any invented fact in the LLM's explanations.

Our first UI was cluttered. We showed it to experienced hackathon hosts, and their feedback made us think like the judges. We redesigned it as a simple four-step story (what broke, what the agents think, how they decided, did it work), with details hidden until someone asks for them.

Learning under pressure. Almost everything here was new to us, and we had a day to make it work.

What we learned

How to work under time pressure and make decisions with a deadline.
Using AI to build fast only works if you understand what it built.
Talking to other competitors and hosts taught us what's happening in tech and how experienced teams manage their projects.
Personally, I learned how much ground I still have to cover compared to the other competitors, and that gives me a clear list of things to learn next.