Inbox. A cross-session feed of everything that needs a human, ranked by urgency, not by session. A layout plugin over tool calls awaiting approval, runs (failed/finished), artifacts, Discord resources, telemetry (budget). Acting on a card answers the session in place; the transcript is one click away.

Board of runs. Kanban where a card is one run (an agent working toward a goal across turns). Columns are run state; the card shows the live current tool call. View over runs, turns, tool calls, envs. Dragging a card from "failed" to "queued" retries it with your note.

Mission control. A wall of live tiles, one per active session: tail of the transcript, running tool call, cost, env. Built for a second monitor. View over sessions, turns, tool calls, envs, telemetry. Hover zooms a tile in place; the zoomed one below accepts input directly.

Env as the main view. The machine is the page: its checkout, shells and today's changes. Sessions are secondary, shown as authors of lines. View over an env, its files, terminals, and the tool calls (edit/write) that produced each hunk. Gutter colour = session; hovering a line reveals the turn that wrote it.

Repo timeline. One time axis for a checkout: git commits, agent sessions (as vertical lanes), CI runs and deploys. View over a repo's commits joined to the sessions and turns that produced them, plus CI/deploy resources. A commit expands into the conversation that led to it.

Day timeline. One lane per session, agent or person; a block is a turn coloured by model (striped = waiting for a human), ticks are tool calls. View over turns, tool calls, people's presence and telemetry. Drag the scrub line; the cards below show each lane's state at that instant.

Replay. A finished (or running) session as a timelapse: every pane is reconstructed as it was at turn N: the file being edited, the terminal, the browser the agent drove. Transcript runs as subtitles. View over one session's turns, tool calls, files (snapshots), terminal output and browser screenshots. Good for review, onboarding Ada, or "what did it actually do".

The room. Presence first: who is here, what each person's agents are doing, and shared sessions drawn as tables people sit at (sit down = join the session; agents are seats too). View over people, sessions (membership), runs, Discord resources. Walking up to a table shows its live tail without joining.

Project dashboard. One project ("pi") as an operations page: every resource with health (MCP servers, envs, model providers, tokens, bots), spend per person and per model, open questions, recent artifacts and members. View over resources, telemetry, people, artifacts and pending tool calls.

Gallery. Everything agents produced, as a visual grid: artifacts (explainers, reports), screenshots from browser tool calls, diffs, PDFs, charts. View over artifacts and file outputs of tool calls; every tile links back to its origin (session + turn) and can be filtered by session, person, kind and time.

Canvas. An infinite board where any addressable thing can be dropped as a live node: notes, sessions, envs, artifacts, files (decisions.md), people. Wires are typed relations (blocks, writes to, owns, discusses). The board itself is context: "ask the agent about this board" sends the selected nodes and wires to a session.

Traces. One run as a waterfall: model latency vs tool time vs waiting for the user, with runtime spans (chord.app.start, esbuild builds) nested under the tool calls that caused them. Below, a cost heatmap per hour × model. View over telemetry spans, turns, tool calls of one run, and spend telemetry of the project.

Decisions. Every decision made in the project, harvested from decisions.md files and transcripts (an ask_user answer, "let's go with…", a reversed choice). Each links to who decided, when, the alternatives, and the turn where it happened. View over files, turns, people; supersession chains show when a decision was overturned.

Plans and todos. One task list across sessions and people, with dependencies between sessions ("step 0b waits for kit review"). Todos come from agent plans (todo tool calls), handoffs and humans. View over runs, todo items in turns, people; the graph on the right shows the critical path.

Knowledge graph. Files, concepts, decisions and the sessions that discussed them, as a node graph built from transcripts (which turns read/edited which files, which concepts co-occur). View over files, sessions, turns, decisions, people. Searching "reload" lights up its cluster; edge weight = number of turns linking two nodes.

Calendar and mail. Time as the organising axis: a week with scheduled agent runs, reminders agents created, meetings from Google Calendar; and mail threads that become sessions. View over scheduled runs, reminders (from turns), calendar and Gmail resources (via gog). Dragging an agent run moves its schedule.

Voice-first. The phone as a radio: a spoken digest rendered as large text and a waveform, then drill-down chips you can tap or say. No transcript scrolling; one thing at a time. View over the inbox (pending tool calls, finished runs) and runs, summarised by a small model; answers go back as tool results.

Terminal tiling. A tmux-like TUI where every pane is an addressable thing: a session, an env shell, a log/telemetry stream, the inbox. Keyboard only, splits are saved per project. View over sessions, envs, tool calls and telemetry; runs over SSH on any env.

Ambient. p3 when you are not looking at p3: a phone lock screen, a desktop menu-bar item, a watch complication. One number that matters ("1 agent needs you", red) and actions that answer without opening the app. View over the inbox (pending tool calls) and run counts; grant/approve actions call back into the session.