Trako: Slack agent that fixes bugs and proves it on video

Production broke? Trako already fixed it. An agentic Slack app that detects incidents, finds the root cause across Sentry + GitHub + CloudWatch + Linear, ships a fix, and proves it works with video.

Comment

Inspiration

I worked as a developer for 7 years, so I know exactly how painful debugging production is. A Sentry error comes in, and then the real work starts: hours cross-referencing CloudWatch to find the logs from when the error occurred, digging through the code for the potential cause, then trawling GitHub to see what changed around that time that could have broken it. Only then can you implement a fix — and test it, and hope you got it right.

AI has made each of those steps faster, but the fundamental problem hasn't changed: it's still multi-system coordination done by a human, and it's still reactive. Someone has to notice and report the bug first — and by then the website might have been quietly broken for weeks, with revenue already lost.

That's the gap Trako fills. Not another Slack assistant that summarizes threads — an agent that closes the loop:

🚨 Detect → 🔎 Diagnose → 🛠️ Fix → ✅ Verify → 📝 Postmortem — all in one Slack thread, with a human approving every consequential step.

What it does

  • 🚨 Detects on its own — a Sentry alert webhook opens and investigates the incident automatically. No one has to notice, no ticket has to be filed.
  • 🔎 Diagnoses across every system — Claude, in a tool-calling loop, correlates the Sentry stack trace, the culprit GitHub commit, CloudWatch logs, and related Linear issues via MCP — and names the cause down to the exact offending line, not just the symptom.
  • 🛠️ Fixes with one click — a responder approves, and Trako either opens a pull request (it never merges — a human reviews) or, for UI bugs…
  • 🌐 Verifies in a real browser with video proof — this is the part no other Slack agent does. Trako applies the fix, drives the actual app with Playwright, has Claude vision judge the result, and posts a video each round — automatically trying a different approach if the first attempt fails, until the bug is genuinely gone.
  • 📝 Writes the postmortem — auto-resolves the incident when the error rate recovers, drafts a structured postmortem as a Slack canvas, and files it to Linear with one click.
  • 🧑‍⚖️ Keeps a human in the loop — Trako proposes; you decide. Every consequential step is a button, not an assumption.

How we built it

Trako is a FastAPI service running Slack Bolt, with Claude as the agent in a tool-calling loop — it decides which systems to query, it's a real agent, not a script. Each external system (Sentry, GitHub, CloudWatch, Linear) is a pluggable MCP connector, so Claude correlates across all of them in a single investigation instead of being pointed at one tool at a time.

The browser verification is the fun part: a pluggable verification environment applies the candidate fix, Playwright drives the page and records a video, and Claude's vision judges the screenshot — fixed or not — looping until it passes (you set the max attempts). The same engine has two modes: a local demo mode, and a commercial mode that commits the fix to a branch, deploys to a preview environment, and verifies against that. This is genuinely the same loop you'd point at a real product.

It's multi-tenant and secure from day one: per-workspace OAuth for GitHub/Sentry/Linear, tokens encrypted in DynamoDB, and all the infrastructure defined in AWS CDK. I also built a mock "production" checkout service that breaks on demand — bad deploys, buggy JS, Sentry errors — so the whole detect-to-postmortem lifecycle can be demoed end to end.

Challenges we ran into

  • Webhooks don't know who you are. Sentry's webhook carries no Slack workspace ID, so I built org-slug → workspace routing that's captured automatically during OAuth.
  • MCP auth in the real world is messy. The Sentry MCP requires Dynamic Client Registration bound to your redirect URI, and some servers (looking at you, Linear 👀) happily return 200 on initialize() and then 401 on the first actual tool call. I built proactive and reactive token refresh to survive it.
  • Judging "fixed" is genuinely hard. A fix can compile, deploy, and still be wrong. Letting Claude vision look at the rendered page — like a human QA would — and feeding its verdict back into a retry loop was the breakthrough.

Accomplishments that we're proud of

  • I closed the entire loop — detect to postmortem — with a human in control of every consequential step. Most "AI incident" tools stop at summarizing the problem. Trako goes all the way to a verified fix and a filed postmortem, and it does it without ever taking an irreversible action on its own. Getting that autonomy-vs-safety balance right, as buttons instead of assumptions, is the thing I'm proudest of.
  • The agent proves its own work — on video. This is the part I didn't think I'd land. Trako applies a candidate fix, drives the real app in a headless browser with Playwright, has Claude's vision judge the rendered result like a human QA would, and posts a video each round. When the first fix fails, it doesn't give up — it tries a different approach and re-verifies until the bug is genuinely gone. An agent that can be wrong, notice, and correct itself is a categorically different thing from one that emits a plausible patch.
  • One agent, four live systems, one investigation. Correlating a Sentry stack trace, the culprit GitHub commit, CloudWatch logs, and related Linear issues in a single tool-calling loop — and having Claude name the cause down to the offending line — meant solving real-world MCP auth (Dynamic Client Registration, servers that 200 on initialize() then 401 on first call, proactive + reactive token refresh). Every one of those was a wall I had to get through, and the fact that it now "just works" in one thread still feels like magic.
  • It's production-shaped, not demo-shaped. Multi-tenant per-workspace OAuth across GitHub/Sentry/Linear, tokens encrypted in DynamoDB, infra as AWS CDK, and the same verification engine running in both a local demo mode and a commercial mode that deploys to a real preview environment. I didn't build a thing that looks like it works on stage — I built the thing you'd actually point at a real product.
  • I shipped all of it solo. The FastAPI/Slack Bolt service, the agent loop, four MCP connectors, the browser-verification environment, the encrypted multi-tenant infrastructure, and a breakable mock production app to demo the full lifecycle — end to end, on my own, inside a hackathon.

What we learned

That the hard part of agentic apps isn't the model — it's the plumbing: OAuth across four providers, multi-tenant token storage, webhook routing, and MCP quirks. And that verification is what separates an agent from a chatbot. Anyone can generate a plausible fix; making the agent prove the fix works, in a real browser, on video, is what makes it trustworthy enough to put in front of a team.

What's next for Trako: Slack agent that fixes bugs and proves it on video

Every integration is an MCP connector, so the same detect-diagnose-fix-verify engine extends naturally to Jira, GitLab, Bitbucket, and Datadog — whatever stack a team already runs. Trako isn't a one-off demo; it's a platform for closing the loop on production incidents.

Built With

Share this project:

Updates