Back to build
Live 4-Agent Pipeline Big Tech Agentic

📋 PIR Generator

Paste a raw Slack incident thread. Get a complete, blameless Post-Incident Review — with hallucination detection built in.

Live demo — the sample thread is pre-loaded. Hit Generate PIR and watch all 4 agents fire in sequence.  ·  Open in full tab ↗  ·  GitHub ↗

Product notes

After a major incident, someone has to write the PIR. In practice, that means one engineer — usually the on-call who just spent an hour fighting the fire — synthesising a chaotic Slack thread into a structured, blameless document while the adrenaline wears off. It's the worst possible time to do careful analytical writing.

This tool automates the first draft. Paste the thread, get a complete PIR: reconstructed timeline, root cause analysis with a causal chain, contributing factors, customer impact, action items, and a lessons-learned section. The output isn't a template-fill — it reasons about what actually happened.

The audience
Built specifically for big tech engineering teams — where PIRs are a cultural ritual, incidents are complex and multi-actor, and the gap between "what the Slack thread says" and "what actually happened" is often significant. The 4-agent design exists precisely because collapsing this into one prompt produces shallow output.
The verifier — the interesting part
The 4th agent re-reads the original Slack thread and fact-checks the finished PIR against it — flagging hallucinations, misattributions, numbers presented as confirmed that were actually estimates, and inferences the Analyst made that aren't supported by the thread. It's a model checking its own pipeline's output. Critical findings are red, warnings amber, notes blue.

Technical discussion

Three agents in sequence is the straightforward design. The fourth agent — the Verifier — is the architectural bet. The core problem with a single LLM pass over an incident thread is that the model will confidently fill gaps. It knows what a good PIR looks like, so it will write one — even if the thread doesn't actually support certain conclusions.

Separating extraction, reasoning, and writing into distinct agents with strict output schemas at each step reduces this significantly. The Extractor is forbidden from interpreting — it only pulls what's explicitly stated. The Analyst reasons over structured JSON, not raw text. The Writer converts structured analysis to prose. Each handoff is a schema boundary that limits hallucination surface.

📥 Slack Thread
→
🔍 Extractor
→
🧠 Analyst
→
✍️ Writer
→
🔎 Verifier
→
📋 PIR
🔍 Extractor
Pulls structured facts from the raw thread — no interpretation. Timestamps, participants, signals, numbers, actions. Flags anything uncertain.
🧠 Analyst
Reasons about root cause, trigger, causal chain, and contributing factors. Distinguishes correlation from causation. Writes in blameless language.
✍️ Writer
Converts structured analysis into a complete PIR document — timeline table, root cause narrative, action items, lessons learned. Prose only, no hallucinating.
🔎 Verifier
Fact-checks the PIR against the original thread. Flags hallucinations, misattributions, false certainty, and unsupported inferences by severity.

The backend runs on Railway (not Vercel) because the 4-agent pipeline takes 40–60 seconds end to end — well over Vercel's 10-second serverless timeout. Progress streams to the UI via Server-Sent Events, so each agent lights up as it completes rather than the user staring at a spinner. Cost per run is approximately $0.09 at current Claude Sonnet pricing. Rate limited to 10 requests per hour per IP.

Claude Sonnet 4.6 Python + Flask SSE Streaming Railway Vercel (frontend) flask-limiter flask-cors