Supercharge your AI with Incident Postmortem Prover. Turns incident narratives into auditable investigations.
Gemini Works with every AI agent you already use
…and any MCP-compatible client
Connect to your AI in seconds.
Incident Postmortem Prover forces SRE-grade rigor into your incident reports. It reviews raw postmortems and flags common failures: incomplete timelines, surface-level root causes, mixed contributing factors, or action items with no clear owner or deadline.
This MCP ensures every write-up is a complete investigation, not just a narrative summary.
What your AI can do
Validate incident postmortem
Checks your draft postmortem against five failure modes: incomplete timelines, shallow root causes, mixed factors, vague actions, and ignored patterns.
Analyzes raw text to ensure every time gap during an incident is accounted for by a specific alert, action, or decision.
Drives the analysis past symptoms ('The server crashed') until it isolates a true organizational or process failure that enabled the outage.
Forces the distinction between the single enabling root cause and secondary conditions that only amplified the impact.
Generates remediation tasks requiring a specific Owner, Deadline, Action, and Success Metric to prevent them from being ignored.
Compares the current incident against past records to flag recurring service issues or shared failure modes.
Ask an AI about this
Compatible AI Apps
OAuth 2.0 Compatible Gemini Waiting for input…
Incident Postmortem Prover: 1 Tool Available
Use this tool to run your draft postmortems through a rigorous audit process that checks for timeline gaps, shallow root causes, vague actions, and historical patterns.
Make your AI actually useful.
Add this MCP to Claude, Cursor, or Windsurf and your AI stops guessing. It gets real tools to look things up, take action, and handle the stuff you keep doing by hand.
Start using Incident Postmortem Prover on VinkiusValidate Incident Postmortem
Checks your draft postmortem against five failure modes: incomplete timelines, shallow root causes, mixed factors, vague actions, and...
Connect to your AI in seconds. Security and governance baked right in.
Pick your AI client below to get set up. Just create a Vinkius account, subscribe, and you're instantly up and running. We handle the entire backend infrastructure, delivering out-of-the-box support for HTTPS Streamable, SSE, and OAuth2—zero messy routing required.
Claude AI
Open Claude Settings
Go to claude.ai, click your profile icon, then navigate to Customize → Connectors.
Add Custom Connector
Click the "+" button and select Add custom connector. Paste your Vinkius endpoint URL:
https://edge.vinkius.com/[YOUR_TOKEN_HERE]/mcp
Replace [YOUR_TOKEN_HERE] with your token from
cloud.vinkius.com. For OAuth-protected servers, expand Advanced
settings to add credentials.
Start a conversation
Open a new chat. The Incident Postmortem Prover integration is available immediately — no restart needed.
Choose How to Get Started
Build a custom MCP for your own tools, or connect a ready-made integration from our catalog.
Build Your Own
Turn any API into an MCP. Import a spec, define Agent Skills, or deploy with MCPFusion.
- Import from OpenAPI, Swagger, or YAML specs
- Create Agent Skills with progressive disclosure
- Deploy to edge with MCPFusion framework
- Built in DLP, auth, and compliance on every call
- Real time usage dashboard and cost metering
- Publish to catalog or keep private
Make Your AI Do More
Start with Incident Postmortem Prover, then connect any of our 5,000+ other servers whenever your AI needs more. One click, no limits.
- Use this MCP plus 5,000+ others, all in one place
- Add new capabilities to your AI anytime you want
- Every connection is secured and compliant automatically
- Track usage and costs across all your servers
- Works with Claude, ChatGPT, Cursor, and more
- New servers added to the catalog every week
Independent Platform Disclaimer: Vinkius is an independent platform and is not affiliated with, endorsed by, sponsored by, verified by, or otherwise authorized by Incident Postmortem Prover. All third-party trademarks, logos, and brand names are the property of their respective owners. Their use on this website is strictly for informational purposes to identify service compatibility and interoperability.
VINKIUS INFRASTRUCTURE
Cloud Hosted
Managed infra
V8 Isolated
Sandboxed per request
Zero-Trust Proxy
No stored credentials
DLP Enforced
Policy on every call
GDPR Compliant
EU data residency
Token Compression
~60% cost reduction
Works with Claude, ChatGPT, Cursor, and more
The Model Context Protocol standardizes how applications expose capabilities to LLMs. Instead of operating in isolation, your AI gains direct access to external platforms, live data, and real-world actions through secure, standardized connections.
This connection provides 1 powerful capabilities that interface natively with Claude, ChatGPT, Cursor, and other compatible AI platforms. No middleware. No custom integration required.
The Postmortem Aftermath: Too much story, not enough data.
Today, writing up an incident involves gathering Slack threads, pulling timelines from different dashboards, and stitching together a narrative. You write 'The service went down because the database hit capacity.' It's vague, it feels complete, but it’s empty. You spend hours copy-pasting data into a document that ultimately fails to identify *why* you should have been alerted in the first place.
With this MCP, your agent forces accountability. Instead of accepting 'The database hit capacity,' you must answer why the system didn't catch it—was there no pre-check? Was the alert threshold too high? The output is a structured analysis that points to process flaws, not just technical failures.
Incident Postmortem Prover: Guaranteed rigor for every incident review.
Manual reviews often miss the critical steps: separating contributing factors from the true root cause, or forgetting to add an owner and deadline to a crucial action item. These manual gaps are where systemic failures hide.
This MCP closes those gaps by running structured checks against five known failure types. The result is an investigation that sticks because it’s built on verifiable data points, not hopeful conjecture.
What your AI can actually do with this
Writing up an incident review is usually worse than the actual incident. You end up with vague stories: 'The site went down for about two hours.' That report accomplishes nothing. This MCP makes sure your analysis stands up to scrutiny. It forces you to reconstruct every minute of the outage, requiring timestamps for every alert, action taken, and decision made during the chaos.
Crucially, it pushes past the obvious symptom—like a service crashing—to find the actual systemic or process failure that allowed it. The tool demands accountability by forcing owners, specific deadlines, and measurable outcomes on all action items. If you need to prove your incident was more than just bad luck, this MCP is how you do it.
You'll connect everything through Vinkius, making the rigorous postmortem process an automated part of your workflow.
019ea631-e58d-726a-9586-bb8eeb6faf58 
Here's how it actually works
The bottom line is, it turns your messy narrative into an actionable, auditable investigation that points to process fixes, not finger-pointing.
Feed the MCP your raw draft postmortem, including timeline notes and proposed fixes.
The tool analyzes the text, running it through 5-Whys chains to find systemic gaps and checking timelines for missing minutes.
You get back a verdict detailing exactly which failures occurred (e.g., 'ACTIONS_UNACCOUNTABLE') and specific questions you must answer before the report is considered complete.
Who is this actually for?
Anyone who writes postmortems and has ever heard the phrase 'we'll circle back to this.' It's for the ops engineer tired of writing reports that get shelved. If your team needs to prove they learned anything from a major outage, you need this.
Needs to enforce standardized documentation rigor across multiple services and ensure all incident reports lead to concrete, tracked action items.
Responsible for building a culture of blameless learning. Uses this MCP to audit team write-ups and elevate the quality of organizational knowledge.
Needs a quick, objective way to vet an incident summary immediately after an outage, making sure nothing critical was missed in the immediate aftermath.
What Changes When You Connect
Stops vague timelines dead. Instead of 'The site was down for an hour,' it forces you to account for every minute, pinpointing the exact process gap that caused a delay.
Goes deeper than symptoms. It doesn't just say 'the server crashed.' It demands five Whys until it finds the organizational flaw—like flawed incentives or poor testing culture—that truly enabled the failure.
Ensures every action item is solid. You can't write 'add monitoring.' The tool requires an Owner, a specific Deadline, an Action plan, and a measurable Success Metric (ODAS).
Prevents finger-pointing. By separating the single root cause from contributing factors, you focus fixes on what actually enabled the failure, not just what happened to it.
Builds institutional memory. It automatically cross-references current outages against your incident history, making sure 'first time' requires hard evidence.
See it in action
The team needs to pass a compliance audit.
A major outage happened last quarter, and the CTO wants proof that the root cause was addressed. Your agent runs the incident postmortem through validate_incident_postmortem, which flags missing owner-deadline metrics on previous action items. You now have a bulletproof report proving accountability.
The bug keeps coming back in the same service.
You've seen this issue three times this year. Instead of writing a new postmortem, you run validate_incident_postmortem to cross-reference history. The tool flags that the root cause type and deployment window match previous incidents, forcing systemic pattern detection.
The initial report is too vague.
An engineer writes: 'Connection pool was exhausted.' This sounds shallow. You run validate_incident_postmortem. The tool rejects it immediately, demanding the next Why: 'Why did the connection pool exhaust?'—forcing you to find a leak or bad query instead.
The incident timeline is fuzzy.
The on-call notes say: 'Around 3 PM things got messy.' You run validate_incident_postmortem and it rejects the summary, demanding minute-by-minute timestamps for every alert fired, person paged, and decision made.
The honest tradeoffs
Blaming a single mistake
Writing 'The junior engineer forgot to update the config file before deploying.' This stops at blame, not cause. It's easy and unsatisfying.
Run validate_incident_postmortem to force the 5-Whys analysis. The tool will push past the mistake to ask: Why was manual config management allowed? What automated validation step failed?
Writing 'multiple causes'
Listing 'Friday deploy, high alert threshold, and missing test' as separate root causes. This confuses remediation efforts.
Use validate_incident_postmortem to isolate the single enabling root cause (e.g., 'Missing integration test'). The other items are just contributing factors that amplified the damage.
Adding vague action items
'We need to improve monitoring' or 'Fix the deployment pipeline.' These statements have no owner, date, or success metric.
The tool forces ODAS: '[Alice] [By: 2024-12-31] [Deploy connection pool alert at 80% threshold] [Success: Alert fires in staging within 30 seconds].'
When It Fits, When It Doesn't
Use this MCP if your goal is to transform an informal, narrative account of downtime into a legally and technically defensible investigative document. You need proof that the fix addresses systemic failure points—not just symptoms. Don't use it if you simply want to summarize what happened quickly for a non-technical executive update; those are better handled by simple status reports. If you only need to list bullet points of what went wrong, this tool is overkill. It requires deep operational data and a commitment to the 5 Whys process.
Questions you might have
How does the Incident Postmortem Prover work with existing incident history? +
The tool cross-references your current analysis against historical records. It flags when a service or cause type repeats, forcing you to prove whether this is truly a 'first time' event.
Can I use validate_incident_postmortem if the incident was very complex? +
Yes. The tool handles complexity by breaking it down into discrete checks: timeline gaps, root cause isolation, and ODAS verification. It treats massive data sets as a series of required proofs.
Does this MCP rewrite my full postmortem for me? +
No, it doesn't write the report. It acts as an auditor; you provide the draft, and it gives you a verdict listing exactly what needs to be fixed—like adding owners or refining timelines.
What is the difference between root cause and contributing factor in this MCP? +
The tool forces separation. The root cause is the single, enabling failure (e.g., no integration test). Contributing factors are secondary conditions that made it worse (e.g., deploying on Friday).
How do I connect my AI client to use the validate_incident_postmortem tool? +
You simply enable access through your preferred AI client within Vinkius. Once connected, you'll get instant access to this MCP and all other available tools in the catalog.
What kind of source material should I feed into validate_incident_postmortem? +
The tool handles both detailed narrative summaries and raw incident logs. The deeper and more granular your input is, the more precise its timeline reconstruction and root cause analysis will be.
If my postmortem is vague or incomplete, how does validate_incident_postmortem guide me? +
It forces rigor by pointing out gaps. If you skip minutes in your timeline or stop at symptoms instead of systemic causes, the tool will flag it and demand specific evidence.
Are there restrictions on how many times I can run validate_incident_postmortem? +
Vinkius handles resource management across all MCPs. While we recommend using this for deep analysis, you won't encounter typical API rate limits when working within the platform.
What makes a timeline 'complete'? +
Minute-by-minute entries from first alert to full resolution. Each entry: [HH:MM] [Actor] [Action] [Outcome]. 'Around 3 PM' is rejected. '15:03 — PagerDuty alert fired for p95 > 2s on /api/orders' is accepted.
How deep should the 5 Whys analysis go? +
Until you reach a SYSTEMIC root — not a human error. 'Bob forgot to restart' is blame. 'The deployment pipeline has no post-deploy health check' is a system fix. The 5th Why should expose a process, architecture, or policy gap.
What makes an action item 'accountable'? +
Three requirements: (1) Named owner — not 'the team'. (2) Deadline — not 'soon'. (3) Success metric — not 'improved'. Example: 'Owner: @maria, Deadline: 2024-02-15, Metric: p95 latency < 500ms for 7 consecutive days.'
We've already built the connector for Incident Postmortem Prover. Just plug in your AI agents and start using Vinkius.
No hosting. No infrastructure. No complex setup.
All 1 tools are live and waiting.
You're up and running in seconds.
Gemini Vinkius gives your AI agents access to the full catalog of app connectors, all fully managed, secure, and enterprise-ready. One subscription, every tool you need.
Built, hosted, and secured by Vinkius. You just connect and go.