Incident Post-mortems: Every Revision a New Version, Every Action Item Filed Once
The post-mortem is written from deployment events and pull requests, then reissued as a new document for each review note, with earlier versions left untouched and tracker issues filed exactly once. The review lead approves every version.
A post-mortem is rewritten more often than it is read
The first version is the easy one. The timeline comes from the deployment events, the contributing changes from the pull requests that shipped in the window, and the action items from the review meeting. Then the review lead wants the contributing-factor lines in a different shape, support wants the impact written for the people it goes to, and platform changes which deploys count as part of the change set. Each note means a new version, and every earlier one has to stay exactly as it was approved.
The evidence is in Vercel: the project's deployments and the production alias's event stream, both read only. The pull requests are in GitHub, which is also where action items are filed as issues. The post-mortem standard and every review note sit in Google Drive, each version is a Google Doc, and the conversation runs in Slack. Editing the last version in place, filing the action items twice or carrying an old change set into a new rule are the mistakes that make a post-mortem hard to trust.
Who works in the room
People
Incident review lead
Runs the review, sends notes on each version and approves every version and the tracker issues
Support lead
Says who the post-mortem goes to outside engineering and how impact is written for them
Platform lead
Owns the rule for which changes belong in the change set
Agents

AdaPost-mortem writer
Writes each version as a new Google Doc from Vercel deployments and events and GitHub pull requests, changing only what the note asks for
Vercel
GitHub
Google Docs
Google Drive
MycoVersion checker
Compares each version with the one before line by line, proposes the tracker issues once, and shares approved versions in Slack
Each incident gets its own Kylon room. Ada is the default agent and writes every version, so a new note goes to Ada whether or not anyone names it. Myco checks each version against the last and owns the tracker issues, as the room guidelines say, so filing happens once and in one place. Ada hands over by opening a thread for Myco whose first message is the brief: which version, which note, and which sections should and should not have changed.
Five versions of one incident
Every version is a new document. Nothing is published, filed or shared until the incident review lead approves it.
- Agent works
- Person decides
- Arrives or gets recorded
flowchart TD
v1["<b>Ada</b> writes v1 from Vercel and GitHub"]
ok1["<b>Review lead</b> approves the draft"]
v2["<b>Ada</b> writes v2 as a new doc, with<br>the change set in the note's shape"]
ok2["<b>Review lead</b> approves"]
v3["<b>Ada</b> writes v3 with the action<br>items in the new shape"]
issues["<b>Myco</b> proposes one issue per action item"]
ok3["<b>Review lead</b> approves the doc<br>and issues before they are filed"]
v4["<b>Ada</b> writes v4 with impact restated<br>for the readers support named"]
support["<b>Support lead</b> confirms the impact lines"]
v5["<b>Ada</b> re-derives the change set in v5<br>under platform's rule"]
cmp["<b>Myco</b> compares v5 with v4 line by line"]
platform["<b>Platform lead</b> confirms the rule,<br>the <b>review lead</b> approves"]
back([A section that moved without a<br>note goes back to Ada])
v1 --> ok1 --> v2 --> ok2 --> v3 --> issues --> ok3 --> v4 --> support --> v5 --> cmp
cmp -->|passes| platform
cmp -->|a section moved| back
class v1,v2,v3,issues,v4,v5,cmp agent
class ok1,ok2,ok3,support,platform person
class back event
classDef agent fill:#FFFFFF,stroke:#DCD3C8,color:#1B1712
classDef person fill:#EEF0E3,stroke:#6E7447,color:#1B1712
classDef event fill:#F4ECDD,stroke:#F4ECDD,color:#564C42| Stage | What happens | Who acts | Who decides |
|---|---|---|---|
| v1, first edition | Timeline, change set, impact, action items and summary, written from Vercel events and deployments and GitHub pull requests | Ada | The review lead approves the draft |
| v2, contributing factors | Everything restated in a new doc, with each change in the set written in the shape the note gives | Ada, then Myco for the comparison | The review lead approves |
| v3, action items | Action items rewritten in the new shape, and one GitHub issue proposed per item | Ada, then Myco for the issues | The review lead approves the doc and the issues before they are filed |
| v4, impact lines | Impact restated for the readers support named, with no new issues | Ada | The support lead confirms the impact lines |
| v5, change set rule | The change set and the trigger are re-derived under platform's rule, so changes leave or join | Ada, then Myco for the comparison | The platform lead confirms the rule and the review lead approves |
When the note changes the shape, and when it changes the facts
Most notes change how something is written, not what happened. For those, Ada restates the whole post-mortem in a new Google Doc and changes only the sections the note covers, and Myco compares the new version with the last one line by line. If the timeline moved when the note was about action items, the version goes back to Ada before anyone outside the room sees it. Earlier docs are never edited; each stays as it was approved.
Platform's note on v4 is different, because it changes a rule rather than a format. Under the new rule only deploys promoted to the production alias belong in the change set, so Ada re-derives the set from the Vercel records, which have not changed since v1. Two changes leave and their lines go with them; one joins and is written in the same shape as the rest. The timeline, the action items and the six tracker issues filed with v3 stay exactly as they are, and the run history shows which records each version was built from.
What the checks catch
- A new version that edits an earlier doc instead of being written as its own
- Tracker issues proposed again after v3, which Myco drops before the lead sees them
- An action item in the doc that was never agreed at the review meeting
- A change kept in the set under the new rule only because it was in the set before
- A timeline or impact line that moved in a version whose note did not ask for it
What stays with people
- Approving each version before it is published or shared
- Approving the tracker issues before they are filed, once
- Reading a note whose wording leaves room for doubt, and deciding what it means
- Deciding who outside engineering receives the post-mortem
Integrations in this workflow
Kylon is not an incident management tool and it does not replace one. It pulls from the hosting platform and the code host, writes into the documents the team already works in, and holds the coordination between them.
GitHub
Google Docs
Google Drive
Slack
Vercel
- Vercel supplies the project's deployments and the production alias's event stream, read only
- GitHub supplies the pull requests and holds the tracker issues for the action items
- Google Docs holds each version of the post-mortem as its own document
- Google Drive keeps the post-mortem standard, the review notes and the roster of action item owners
- Slack is where the review happens and where each approved version is shared
Where to start
Try it on your next incident review. Connect the Vercel project read only and the repository where action items are filed, give the room the Drive folder that holds your post-mortem standard, and write one rule in the room guidelines: every version is a new document, earlier ones are never edited, and tracker issues are filed once, after the review lead approves them.
“Five versions, five documents and one set of tracker issues. Anyone can open v2 and read exactly what was approved that day.”
Set it up with your agent
Open a new Room, add your agent and paste this prompt. It connects the tools, builds the App with you and asks for your rules one step at a time, and nothing goes out until a person approves it.
Set up our incident post-mortem desk in this Room. Take it one step at a time and wait for my OK before you move on. 1. Connect GitHub, Google Docs, Google Drive, Slack and Vercel. Tell me which ones still need connecting. 2. Ask me who works this desk: the incident review lead, the support lead and the platform lead. Help me invite them to this Room. 3. Build a Post-mortem Versions App with Version, Note from, What changed and Status, one record per version. Pull each record from the Vercel deployments, the production alias event stream and the GitHub pull requests in the incident window. 4. Check each new version against the one before it line by line. Flag any section that moved when the note did not ask for it, any tracker issue proposed after the first filing and any change kept in the change set only because it was there before. 5. Hold every publish, share and file action until the right person approves. The incident review lead approves every version and every tracker issue before they are filed. The support lead confirms the impact lines. The platform lead confirms our change set rules before the review lead approves the final version. 6. Write into this Room's guideline that every version is a new document, earlier ones are never edited and tracker issues are filed once after the review lead approves them. 7. After each clean incident, offer to turn the version comparison and Slack share into an Automation. Before you start, ask me for our rules one at a time.
Your first company harness. Where humans and agents run your business together.
More Use Cases
View allAPI Deprecation Migration: Cutoff Waves That Stay Right as Integrations Move
Retiring an API version runs through one Kylon room. Agents set a disposition for each customer integration in Attio, schedule cutoff waves from the deprecation policy and track blocking bugs in GitHub, while the API product lead approves every disposition and notice.
Backup Restore Verification: Backups Proven Restorable Within Their Class Interval
A backup counts only once someone has proved it restores. Agents in the team's Kylon room read each backup-job issue in GitHub against restore reports in Box and live targets in Vercel and propose a verdict by class. The reliability lead approves before any issue changes.



