Skip to content
Zooid

The Zooid web client

The Zooid web client is an open-source web Matrix client. At first glance it looks like a regular Matrix client — rooms, timelines, federation — but it is purpose-built for working with AI agents.

The Zooid web client is built on matrix-js-sdk (Apache-2.0) using Vite, React, and a modern design system (shadcn/radix). It is not a fork of Element; it is written from scratch for the agent workflow.

Any standard Matrix client can still be used with Zooid agents, but the Zooid web client provides an enhanced experience for workforce orchestration.

What makes the Zooid web client different

A generic Matrix client like Element can send and receive messages from agents, but it treats agent output the same as human chat: a linear stream of text. The Zooid web client adds layers on top of the standard Matrix experience that make an agent’s work legible — the difference between watching a black box and supervising a colleague.

1. Inline approval and question cards

When a Zooid agent requests human approval, the request renders as an inline card in the timeline with one-click Allow / Deny actions. No copy-pasting IDs, no separate dashboard — the approval lives in the conversation where it makes sense.

When an agent stops mid-turn to ask you something, the question arrives as a card in its thread: text boxes, choices, checkboxes, whatever it asked for, with Submit, Skip and Cancel. You get a notification and the agent shows as awaiting input. A wrong answer gets a note on the field, not a dead end. Once someone answers, everyone sees who did and what they chose, and the agent picks up where it stopped.

2. Live plan board

When an agent plans its work — the todo list it ticks through — the Zooid web client renders it as a single task board that updates in place: items flip from pending → in-progress → done as the agent works, instead of scrolling past as repeated ”✅ done with step 2” messages you reconstruct by hand. It’s the board a non-technical supervisor can glance at to know where things stand. This works uniformly across Claude Code, Codex, and opencode — the Zooid web client reads the plan each advertises over ACP.

3. Tool calls with inline diffs

Every tool the agent runs renders as a collapsible card with its status and output. File edits in particular show as inline diffs — additions and deletions, per file, right in the card — so the single most important thing an agent does (change a file) is visible rather than summarized away.

4. Command palette

The composer’s / menu autocompletes both the web client’s own commands (/clear, /interrupt) and the commands the agent itself advertises — /compact, /plan, and whatever else the underlying CLI exposes — tagged by source. You discover an agent’s capabilities by typing / instead of reading docs.

5. Prompt composer

A dedicated composer for talking to agents, with @-mentions for addressing a specific agent in a multi-agent room, and the command palette above. Attach images and files — and the agent can actually see them: media flows end to end through the daemon to the agent, not just rendered client-side.

If the server turns a message down (say you’re only invited to the room and haven’t joined), the message is marked Not sent with the reason. You can Retry it, which won’t post a duplicate if the first attempt did get through, or Delete it. It never looks delivered when it wasn’t.

6. Rooms that feel like a workspace

Rooms have avatars and topics, editable inline. Conversations with agents run in threads, so parallel work doesn’t collide in one stream. Any thread or message can be passed on: copy a link that opens it directly, quote it into your reply with the author and a way back, or share it to another room with a note — so an agent’s answer in one room becomes the starting point for work in the next. Desktop notifications with per-room preferences ping you exactly when an agent needs you and stay quiet otherwise.

7. Agent-aware UI

The Zooid web client surfaces agent presence dots natively in the timeline, so you know exactly when an agent is typing or idle.

When an agent works on several turns in the same room, its typing indicator stays active while any turn is working. A turn waiting for your approval or answer stops typing; another active turn keeps the indicator on.

Coming soon

  • Sub-agent hierarchy — when an agent delegates, render the work as a nested, collapsible tree: the parent with its children, each with its own status and expandable output — the tree, not the tangle.
  • Agent mode switching — surface and switch the agent’s operating mode (plan vs. build) from the composer.

Status

Shipped. The Zooid web client is available today and ships bundled with the local development stack:

  • Access it via http://localhost:5173 when running zooid dev
  • Deploys as a static bundle anywhere (Cloudflare Pages, Vercel, etc.)
  • Connects to any Matrix homeserver (including the local Tuwunel container)