Finn

Finn is a human-oversight layer for AI decision-making in Slack: a panel of specialist agents debates each incoming request, Finn handles the ones they agree on and routes high-stakes ones to a human

Comment

An AI panel that triages product feedback in Slack — and knows when to just handle it and when to ask a human.

Inspiration

Every team drowns in feedback, and sorting through it is thankless work. The same complaint gets filed as a bug one day and waved off the next, depending on who read it. The reasoning behind each call lives in one person's head and then disappears.

AI can obviously read all that feedback. The hard part is trust. Nobody's going to let a bot quietly open tickets and escalate customer accounts on its own. So the real question isn't "can AI decide?" It's "can it decide in a way you'd actually sign off on?" That's Finn.

What it does

Feedback lands in a Slack channel and Finn pulls together a panel of three specialist agents: Support, Engineering, and Product. Each one investigates with its own tools — support tickets, the issue tracker, the roadmap — and argues its side. They disagree, because they're genuinely looking at different evidence.

Then Finn does the part that matters. It reads the room:

  • When the panel agrees and the call is low-stakes, Finn handles it and logs what it did. Nobody gets interrupted.
  • When they disagree, or the action actually costs something (filing a ticket, escalating an account), Finn writes up the decision, tags the owner, and waits for a yes or no. Nothing hits the outside world without a person.

Every decision, auto or approved, gets written to a Slack Canvas with the reasoning — so the "why" stops evaporating into old threads.

The fun part: the same complaint can go two different ways. A minor gripe from a free user, Finn quietly closes. The identical complaint from an enterprise account two weeks from renewal, it escalates to a human. Who's asking changes the answer, and you can watch it flip live from Finn's home tab.

How we built it

  • Three persona agents plus a judge, all running on the same reusable runner, powered by Claude on Amazon Bedrock.
  • Each agent returns structured JSON through a forced tool call, so the output is reliable instead of scraped out of free text.
  • The agents ground their arguments in real data: Slack's Real-Time Search API for workspace context, and a Zendesk MCP server we built ourselves (hitting a live Zendesk sandbox) for tickets and account health.
  • It runs two ways from the same code: Socket Mode for fast local iteration, and a Lambda deployment (API Gateway, DynamoDB, all Terraform) that judges can hit directly.
  • It's Slack-native end to end: Block Kit cards, custom agent nameplates, live reactions, a home tab of one-click scenarios, a Canvas ledger, and a DM assistant you can actually chat with.

What makes it different

Multi-agent debate and human approval aren't new ideas. The twist is using the panel's disagreement as the signal for when a human is needed. Agree? Handle it. Argue? Escalate it. People spend their attention on the genuinely hard calls instead of the obvious ones, and every decision stays on the record either way.

Challenges we ran into

  • We tested our own premise. It turns out debate rarely changes the outcome on clear-cut cases, so we built around what the evidence supported — smart routing and a clean audit trail — instead of pretending the arguing itself is magic.
  • Getting structured output that holds up across different model phrasings, without brittle text parsing.
  • Because the agents search live Slack, Finn's own past runs started showing up as "evidence" in later ones. A good lesson in keeping retrieval clean.

What's next

  • Swap the last seeded data source (Jira) for a live MCP, like Zendesk already is.
  • Wire real execution in behind the approvals.
  • Take the same panel-and-route pattern to other decision queues: incident response, PR review, access requests.

Built With

Share this project:

Updates