Zodus

Zodus turns scattered Slack conversations into cited answers, native visualizations, and durable plans—so teams know what happened, who owns it, and what to do next.

Comment 1

Inspiration

Workplace questions rarely have tidy answers.

“Are we launching Friday or Tuesday?” might require finding a pinned decision, ignoring an older plan, checking who owns the launch, and understanding why it changed. Even when an AI finds the answer, it usually returns the same thing every time: another wall of text.

We wanted to build something better for organizations using Slack.

Zodus is an AI operating layer for organizations that turns scattered workspace context into the right native Slack interface. It finds the relevant evidence and decides how the answer should be presented. A trend should look like a chart. Structured data should look like a table. A complex request should become a visible plan.

Our guiding idea was simple: presentation is part of reasoning.

What it does

Most Slack agents generate text. Zodus generates the right native Slack interface for the answer.

Ask for the latest launch decision and Zodus uses Slack's Real-Time Search API to find the relevant conversation, distinguish the final decision from older messages, identify the owner, and cite the Slack sources. Search remains permission-aware, so Zodus can only retrieve content the invoking user is allowed to access.

Ask for weekly active users as a trend and Zodus generates a native line chart. Ask for structured records and it can generate a table. Ask for options and it can generate cards. Users may request a format explicitly, but Zodus can also choose the right presentation automatically.

For larger requests, Zodus creates a live task-plan card. The plan shows what the agent intends to do and updates as tasks begin and complete. Runs, tasks, steps, and tool calls are persisted, so the work remains inspectable instead of disappearing behind a loading spinner.

Zodus is designed for organizations rather than single-user demos. An Owner connects Slack through the dashboard, organization context and credentials remain isolated, and members receive permission-aware answers based on what they can access. The same agent can therefore be useful across a company without collapsing its trust boundaries.

For teams, that means less decision archaeology, faster onboarding, and fewer actions based on superseded information—all without leaving Slack or blindly trusting an unsupported AI answer.

The result is one continuous loop:

Find the truth → show the evidence → choose the right interface → move the work forward.

How we built it

We built a typed presentation layer between the model and Slack. The model decides which presentation fits; Zodus decides how to validate and render it safely.

The model does not generate arbitrary Block Kit JSON. It selects a supported presentation and supplies structured data through a constrained tool contract. Zodus validates that data and renders approved Slack components server-side. This keeps the experience generative while preserving predictable, safe, native UI.

The same presentation path works for simple answers and the final results of planned tasks. If a response is completed before its visual presentation is attached, the delivery workflow can replay the upgrade without duplicating the answer.

Underneath the UI, Slack events enter a Cloudflare Worker, are verified and acknowledged quickly, and become org-scoped agent_runs in Postgres. A Durable Object serializes each conversation, while Cloudflare Workflows execute direct answers or validated multi-task plans. Zodus streams progress and results back into Slack.

Its tools include Slack Real-Time Search, workspace memory, web and document tools, and connected external applications. Raw Real-Time Search results remain transient; Zodus persists tool metadata without copying raw Slack search content into durable memory.

We paired that adaptive interface with an organization-grade foundation: a dashboard-first Marketplace installation flow, Owner/Member access controls, Slack OAuth, encrypted organization AI credentials, reconnect and uninstall handling, and reviewer-safe onboarding.

Challenges we ran into

The hardest problem was making generative UI reliable.

Early versions occasionally described a chart without producing one, returned a Markdown table instead of a native table, or skipped the presentation tool. We added clear presentation instructions, typed schemas, server-side validation, regression tests, and delivery-state tracking so the interface shown in Slack matches the user's request.

Planning introduced a similar problem. A model could invent a task type or create a formatting task that did not belong in the execution graph. We kept task permissions strict, validated dependencies, returned exact retry errors, and guaranteed that every tool call ends as completed or failed—never incorrectly stuck as running.

Real-Time Search brought its own constraints: action tokens are short-lived, results must respect the invoking user's permissions, and fresh Slack context should not silently become permanent memory. Designing around those boundaries made Zodus both more useful and more trustworthy.

Accomplishments that we're proud of

We are proud that Zodus's defining experience—generative UI built from native Slack components—is not a mock-up. It works end-to-end with genuine model responses.

Zodus can:

  • search live Slack context and return cited decisions;
  • automatically choose charts, tables, cards, or structured summaries;
  • use the same presentation system for direct and planned responses;
  • stream live progress through durable task-plan cards; and
  • recover presentation delivery without duplicating the textual answer.

We are also proud that this sits on a production, multi-tenant foundation rather than a scripted demo. Zodus has been installed in five active Slack workspaces and submitted to the Slack Marketplace for review.

That combination is what we set out to prove: an adaptive Slack experience that is also trustworthy and deployable across real organizations.

What we learned

We learned that the shape of an answer matters as much as its words.

A chart makes a trend obvious. A table makes records comparable. A task card makes agent progress legible. Generative UI is not decoration—it reduces the effort needed to understand and trust the result.

We also learned that a useful agent needs more than model intelligence. It needs permission boundaries, citations, durable state, truthful failures, and a clear installation experience. Reliability is part of the interface.

Most importantly, Slack is not merely a place to deliver chatbot responses. Its conversations, permissions, and native components make it a powerful environment for building adaptive agent experiences.

What's next for Zodus

Next, we want to make Zodus's generated native Slack interfaces interactive.

The agent will be able to draft an action, render an approval interface, explain the evidence behind it, and wait for an authorized human before proceeding. We also plan to expand the native component catalog, add reusable organization and personal skills, and let customers connect more external tools and MCP servers.

The long-term loop is:

Notice → Explain → Recommend → Draft → Ask for approval

Slack is the first surface, but the organization's context and execution history remain portable. Our goal is for Zodus to become the operating layer that helps a team understand what happened—and gives it the right interface to decide what happens next.

Built With

Share this project:

Updates