Transcend AI

Readiness proof before launch. Accountability answers after failure.

Comment

Inspiration

At midnight, a production incident can appear before anyone has the full context.

A customer incident manager may see the issue first, but not know who truly owns the product, which team shipped the change, whether the person on rota is the right person, or what proof existed before launch. The incident gets assigned to whoever is visible, not necessarily whoever is responsible.

The cost of this confusion is real:

The cost of missing context

Every number above is a post-failure signal.

Transcend AI is built as the pre-failure layer: a Slack-native accountability agent that creates readiness context before launch, then uses that memory after failure to find the right owner, team lead, manager context, and proof trail.

What it does

Transcend AI is a Slack-native agent that turns launch conversations into readiness proof before release and accountability answers after incidents.

Before release, it helps a team move from scattered Slack context to a verified readiness state:

  • Scans launch evidence across conversations, docs, runbooks, QA notes, support plans, and ownership records
  • Detects readiness gaps such as stale owners, missing proof, incomplete QA, outdated runbooks, and unresolved customer communication risks
  • Resolves accountability by identifying the responsible person, team lead, proof participant, and manager context
  • Creates DrillOps proof tasks so the right people submit launch proof directly inside Slack
  • Recalculates readiness from verified human proof instead of AI assumptions
  • Generates a leadership-ready summary explaining the current launch risk and proof state

After an incident, Transcend AI uses the saved readiness memory to answer the questions incident managers usually chase manually:

  • Who owns this issue?
  • Which team lead should be tagged?
  • Which manager has rollout context?
  • What proof existed before release?
  • What risk was still unresolved?

This demo shows a Slack agent that is not only a chatbot, but an accountability layer for teams that plan, launch, and support production systems inside Slack.

How we built it

We built Transcend AI as a new Slack agent for launch readiness and post-check accountability, not as an external dashboard with Slack added later.

The public landing page is hosted at transcendai.netlify.app, but it is only the entry point. Slack is the main product surface. The agent runs through App Home, slash commands, Block Kit cards, modals, and Socket Mode so users can complete the readiness and post-check workflows inside Slack.

Transcend AI Architecture

New Slack Agent experience

Transcend AI is designed around Slack’s agentic surfaces:

  • App Home as the agent dashboard for readiness and post-check
  • Slash commands for /transcend-readiness and /transcend-post-check
  • Block Kit cards for structured agent responses
  • Interactive buttons for step-by-step workflow actions
  • Modals for case creation, proof submission, verification, and post-check questions
  • Socket Mode for the Slack worker runtime

This makes Transcend AI feel like a real Slack agent that guides a workflow, collects proof, updates state, and returns accountability answers inside the workspace.

Agent orchestration

Slack interactions are handled by a Bolt for JavaScript Socket Mode worker.

The worker receives App Home events, slash commands, button clicks, and modal submissions, then sends each action to a backend built with Node.js, Express, and TypeScript.

The backend acts as the agent orchestration layer. It stores case state, runs product engines, writes audit history, and returns structured Slack cards back to the user.

We used Prisma and Neon Postgres to store feature cases, evidence records, detected gaps, proof tasks, proof submissions, readiness state, and audit history.

Product intelligence engines

The main readiness logic is deterministic:

  • MinusZ detects hidden accountability and readiness gaps
  • TeamIntel resolves owners, team leads, proof participants, and manager context
  • DrillOps creates proof tasks inside Slack
  • Readiness Engine recalculates launch state from verified human proof

The important product rule is:

OpenAI explains readiness. It does not decide readiness or verify proof.

MCP-ready post-check path

We exposed the post-incident accountability flow through a POST /mcp endpoint.

The MCP-ready path takes an incident question and returns the responsible person, team lead to tag, manager context, people involved, and proof trail.

For the hackathon, it searches seeded AcmePay incident context and saved readiness state. The architecture is designed so this same post-check path can later connect to Slack MCP and Real-Time Search-style retrieval.

OpenAI and leadership brief

OpenAI is used as an explanation layer after readiness is recalculated.

It generates a leadership-friendly summary explaining what changed, what proof was verified, what risk remains, and why the launch state matters.

We also generate a Canvas-ready leadership brief so readiness does not disappear inside chat history and can become a shareable leadership artifact.

Deployment

Transcend AI is deployed as a real multi-process Slack agent system:

  • Slack Socket Mode worker on Fly.io
  • Express backend API on Fly.io
  • Neon Postgres for case state and audit history
  • Netlify for the landing page
  • OpenAI for leadership explanation
  • MCP-compatible endpoint for post-check tool access

Accomplishments that we're proud of

Proud moment

We are proud that Transcend AI became a real Slack-native product experience, not just an API demo.

The full workflow runs inside Slack using App Home, slash commands, Block Kit cards, interactive buttons, and modals. A user can start a readiness case, scan evidence, review gaps, collect proof, verify readiness, and run a post-check without leaving Slack.

We are also proud of turning a messy enterprise launch problem into clear product layers:

  • MinusZ detects hidden accountability gaps
  • TeamIntel resolves owners, team leads, proof participants, and manager context
  • DrillOps turns gaps into human proof tasks
  • Readiness Engine recalculates launch state from verified proof
  • Post-check Search connects incident context back to saved readiness state

Another major accomplishment is responsible AI use. OpenAI explains the readiness result in leadership-friendly language, but it does not decide readiness or verify proof. The actual readiness state comes from deterministic engines, evidence, and human verification.

Finally, Transcend AI is deployed as a real multi-process system: Slack Socket Mode worker on Fly.io, Express backend on Fly.io, Neon Postgres, Netlify, and an MCP-compatible post-check endpoint.

The result is a working Slack agent with a complete product loop:

Slack → Evidence → Gaps → Owners → Proof → Readiness → Post-check

What we learned

We learned that building inside Slack is very different from building a normal web app.

In a web app, the product controls the whole screen. In Slack, the agent has to work through App Home, messages, modals, buttons, commands, and user context. That forced every step to be clear, structured, and action-oriented.

What we learned building in Slack

The biggest lesson was that Slack agents need more than answers. They need to connect the workflow surface, the product state, and the proof trail.

For Transcend AI, that meant learning how to combine App Home, Block Kit, modals, slash commands, Socket Mode, MCP-ready tool access, OpenAI explanations, and backend orchestration into one agent experience.

We also learned that AI should not own every decision. For launch readiness, trust matters. Transcend uses deterministic engines and human verification for readiness, while OpenAI makes the final state easier for leaders to understand.

Most importantly, we learned that Slack can be more than chat. It can become the operating surface for readiness, proof, and accountability.

What's next for Transcend AI

Next, we want to move Transcend AI from a hackathon-ready Slack agent into a production-grade accountability layer for software teams.

The first step is connecting the post-check path to real workspace context through Slack MCP and Real-Time Search-style retrieval, so Transcend can search live incident channels, launch channels, docs, and people context with proper permissions.

We also want to expand the DrillOps library beyond launch readiness into more accountability drills:

  • Ownership drills
  • Production issue drills
  • Customer communication drills
  • Handoff drills
  • Documentation and runbook drills

Another important next step is workflow safety. Slack messages can live for a long time, so old buttons should become harmless, completed cards should lock, and every failed action should clearly explain what happened and how to continue.

For leadership, Transcend can grow into richer Canvas-ready briefs, weekly readiness digests, launch risk summaries, and post-incident comparison reports that stay connected to the original evidence and proof trail.

Long term, we want to prepare Transcend AI for real Slack workspace installation with OAuth onboarding, permission-scoped evidence access, multi-workspace support, admin setup guidance, security notes, and a clear path toward Slack Marketplace readiness.

The goal stays simple:

Before launch: prove readiness.
After failure: find the right owner fast.

Built With

Share this project:

Updates