Approval Card
An agent asks before it acts: a risk tier, what exactly will happen, Allow and Deny with shortcuts, a countdown that pauses while you read, arming for high risk, hold-to-allow for critical, and a resolved row.
What an agent is doing and what it needs from you: status, tool calls, plans, approvals and checkpoints. 96 components.
An agent asks before it acts: a risk tier, what exactly will happen, Allow and Deny with shortcuts, a countdown that pauses while you read, arming for high risk, hold-to-allow for critical, and a resolved row.
Several open requests in one card: page through them with ‹ › and allow the whole batch once.
An agent's question in its own card above the composer: numbered options with one Recommended, tiles for a pick, Approve / Decline with facts, or your own words.
Paged questions the agent asks before acting: an odometer counter, single choice that moves on by itself, multi-select, your own answer, Skip and Send.
Confirm a destructive action by holding, not tapping: the fill runs while held, rewinds smoothly when you let go early and resumes from where it was on a quick re-press; a check draws in when done.
A destructive button that morphs into an inline question, a spinner and a result with Undo, or an error with Retry. Confirm by press, by hold, or with a countdown Escape can still stop.
A destructive button that grows into a small card: the consequence, an optional type-to-confirm phrase that fills Delete as you type, progress on the button, then a check in the button's shape or the error with Try again.
Every approval request of a run as a stack: the one to decide now on top with who asks, what exactly and why, its input or diff; approve, change it first or reject, and it drops into the Decided list while the next rises. Open gates say how many steps they hold.
An agent asks for one specific right: who, why and exactly what will happen. Allow it once, for an hour or always; it folds into one line with the time left and Revoke. Destructive requests turn Allow red and drop Always.
One card for agents' tool calls: the call in plain words with code set in mono, the agent's reason, editable arguments; approve, deny or always allow for this agent or the whole workspace, which also clears every queued call the new rule covers. Rules and a decision log sit behind tabs.
A focused workspace for what agents want to do: the queue sorted by risk, one item at a time with the shaky spans flagged, and Approve, Edit, Reject and Skip on single keys with undo.
A key the agent can use but never sees: masked to its last four characters, the chat only gets a handle, Show needs a confirm and hides itself after five seconds, Rotate swaps it with a progress bar and Revoke pauses the routines that used it, with Undo.
A lead and its sub-agents as one live tree of cards – what each does now, how full its context is, its tools and the last thing it was handed; handoffs run as a light along the connectors, a click opens the details with steering, and a switcher swaps projects.
Agents in a document like teammates in a multiplayer editor – live pointers with names and costs, suggestions typed letter by letter, an image they resize, code they fix and comment pins beside the page.
A swarm of agents checking something – one calm row per agent with its progress, and their findings sliding into a short feed as they're found.
Agents and the tools they call as a living network – a pulse along the link for every call and its answer, agents that breathe while they work and turn amber when they need you, and a card with each node's latest calls.
A task passed from agent to agent like a relay – at every handoff what went along to the next one, what got lost on the way, and a light running down the line as the card drops in.
All your background agent tasks in one calm list – live clocks and status tags, filter tabs with rolling counts, rows that unfold to the last steps with Approve, Reject, Retry or Open, and glide to their new place.
Where every agent is right now – a live timeline with a lane per agent, tasks growing into now, hand-offs drawn between agents and approvals right on the block.
Everything an agent changed in your systems, each change with an undo – before and after per row, and pointing at Undo shows what would go with it and what can't be taken back.
One agent at work as a card – the current step with a clock and the bill so far, a time strip, the finished steps with each tool's logo, the exact command when it needs an OK, and a fold into a small bar.
The work waiting for your agents and how fast it moves – a live queue, workers running jobs as growing bars, Done and Failed, and a depth chart that shows the backlog build up under a rate limit and drain after.
A catch-up card for when you come back: a tiny timeline of the night with a spike per event, then grouped items – waiting on you, broken, finished – each with its action in place.
One agent run as a sequence diagram – a column for you, each agent and each tool, every message an arrow between lifelines, calls solid and replies dashed, bars while a participant works, and parallel or retried messages in labelled frames.
How much an agent may do on its own – three levels, and its real actions gliding between Runs on its own and Asks you first, with a lock for what always asks.
The While you were away card for a chat thread – how long you were gone, what needs you, what failed and what's done as a short list with one action per row; Got it folds it into a one-line divider.
What agents say to each other – a quiet chat where every message shows who it is from and who it is for, handoffs and questions for you tagged, files as chips that open a preview, details under a message, and a composer that names agents with @.
A treemap of everything in an agent's context: each prompt, tool list, memory, file, chat turn and tool result is a tile sized by tokens, tiles slide as the window fills, unused room stays hatched, and compaction folds old turns into one summary tile.
A run's spend, step by step: model calls, tools and sub-agents stack across to the total, each with its model, tokens in and out, price and duration; the priciest step is flagged and one toggle swaps money for tokens.
An agent at a fork shows each way forward as a branch – what it changes, which parts worry it, which one it would take – and waits for you to pick a path or tell it something else.
One task tried several ways at once: every attempt races as a row with its model, approach and a live bar, finishes with a score, and the best one is marked and used – switch to another if you prefer.
Answers from several models in a knockout bracket judged by another model: open any match to compare both answers, their scores and why one won; once the final is settled the champion's route turns blue.
What the assistant remembers about you, by category: filter or search it, pause a memory, edit or forget it with a short undo, add your own, or switch memory off without losing anything.
A compact pill for an app bar or side rail counting background agent work – how much is running, how much waits on you – that opens to each task's ring, current step, Pause / Resume and Open.
How an agent's run is going against its plan: each step's real bar over a dashed planned one, overruns in amber, later steps pushed right and the expected finish drifting from the planned finish.
Why a run failed, drawn as a fault tree: guesses under OR and AND gates are checked one at a time and ruled out or confirmed, the confirmed route to the failure is highlighted, and any node opens its verdict and evidence.
Which tools an agent can reach and what it did with them: the agent in the middle, every tool of the run around it with a wire where access exists, cards for used, busy, failed or unused, and each tool's calls one click away with a replay.
Agent tasks booked into a week of sessions that each have a usage limit: auto booking fills the gaps with small tasks and cuts big ones across sessions, manual keeps what you booked by hand, and one agent can be picked out.
When agent runs happen across a day, drawn as the token load against an API's per-minute limit: drag a run's bar to move it, spread the runs out to lower the peak, and get the nearest start that keeps a run under the limit.
An agent run as a tree of spans on a time axis: agents, model calls and tool calls as tinted bars that grow while the run goes, the run's totals on top, finished branches folded into marks, and every span's details one click away.
One job split into hundreds of small tasks across a pool of workers: a cell per task tinted by status, counts that filter the grid, the cost and time left, each task's card one hover away and Retry failed.
Hand tasks to agents yourself: a pile of unassigned work beside each agent's model, rate, busy-until time and queue, with the money waiting in queues – or switch on Auto and let whoever frees up first take the next one.
Which model actually served a request: the fallback order drawn as a small flow with a running clock and cost, each failed try broken red with its reason, the one that answered carried through to the response.
One tool call in one line: a live timer, status and summary, MCP server badge, and a fold that opens to arguments (secrets masked) and output; approval and failure open on their own.
A turn's tool calls grouped the way a transcript reads them: runs of reads fold into one line, parallel calls show live, and a finished turn folds into "Worked for 31s".
The agent's task list: done, active, blocked, pending and skipped items, as a checklist or a dock above the composer that fades once everything is done.
The plan as a vertical timeline, each step with its time and the tool calls it made; folds to one line once every step is done.
A plan as a document you review before the agent runs it: drafting, proposed with Approve or Build, executing, or superseded by a newer version.
Who started whom: an orchestrator and its sub-agents with state, time and results, approvals surfaced in place, depth and sibling limits, as an indented tree, a rail, a dock or a terminal.
An agent's step-by-step plan to review before it runs: rename, drag to reorder, remove or add steps, then watch each run with live timers and retry from a failed step.
The steps an agent works through as one quiet trail: a header with the agent's mark, the task and 3/5; done steps with a check and their time; the running step shimmering what it does with a live timer, a short fading light running down the trail into the sub-step it is on; long sub-step lists fold to five (+N earlier, +N more); a gated step waits with a dashed ring and Approval, then Needs you opens Approve and Decline; declined steps are struck through; each step shows its tool's coloured logo. RTL, keyboard and live-region built in.
Live agent tasks as compact rows: a ring with the step for running rows, Completed and Failed pills with Retry, details that open per row, rows entering 80 ms apart. Capsules or list.
Where a person is in a multi-step flow: numbers morph into checks or alerts, connectors fill, descriptions for every step or just the current one, compact markers with a caption, and arrow-key selection of completed steps.
Guide a new workspace through setup: a ring and count, one open step with its action, checks that draw in, Hide / Show, and a done title once everything is complete.
A launch checklist that keeps prerequisites, progress and the final action together: grouped items with owners, blockers called out, a release button that waits for them, a spinner while it runs and an inline alert if it fails.
One goal broken into tasks with estimates, owners and dependencies; a schedule strip per task and a verdict that says whether the deadline holds. Reorder and regenerate.
Who started whom: an orchestrator and its sub-agents as a live tree with status, cost and time on every card, costs rolling up each branch, branches that fold, and Approve / Reject or Retry / Dismiss for agents that need you or failed.
Several agents side by side: each card sums up its sub-agents (running, need you, done, failed) and its branch cost; a click opens its tree to the right while the last one folds back.
A lead agent splits a goal into a plan, fans the subtasks out to parallel worker lanes under a 1–4 concurrency limit and merges what comes back, with each lane's model, progress and result in view.
A table with nested rows, tri-state selection (checking a parent checks everything under it), sort that keeps the hierarchy, lazy children with a retry row, and a pinned header.
Events grouped by day, newest first, on a quiet avatar line: a type filter, new updates held behind a button so nothing jumps, expandable details, unread dots and Mark all read. The timeline variant drops the controls.
Who is working and how: a state dot on the agent's avatar (idle, thinking, working, needs you, error, done), what it does right now shimmering, and for how long.
One card that follows a coding agent through a task: steps stream in with the live one shimmering, the agent stops on a proposed change for you to approve or send back with a note, then the result with Open pull request.
An agent's tool call in one line: live timer, status and summary; folds open to highlighted arguments and result with copy, Retry on errors, and a group that sums them up.
Tool call rows for agent transcripts: the tool's mark and the call in plain words, a live state while it runs, Input and Output a click away (list, table, JSON or text), with approval and retry when needed.
Code edits and tool calls as compact chips: “4 tool calls, 2 messages”, a live state per chip, then file-diff chips whose diff opens on hover or focus.
Raw tool names from any agent (Claude Code, Codex, OpenCode, MCP) mapped to a kind, an icon and running / done verbs, with exact-name and prefix overrides.
Review an agent's change set: unified, split or stacked, Accept / Reject (or Keep / Undo) per hunk, per file and for all with undo, a file list with Viewed marks, hidden context on demand, line comments sent to the agent together, and a minimap.
What an agent changed at a glance: “4 files changed +58 −21”, a block bar, and a row per file with its status and counts that opens the file.
An agent's edits over a run as lines added and removed against time, with a row per file and any edit opened to its changed lines; or one file across revisions on a rail, any two compared.
An AI edit for one file: the instruction and model, a file tab with a running +/− count, hunks that stream in after a short Reading shimmer, Accept / Reject under each, and Accept all with ⌘↵.
An agent's code review in one card: the verdict, open findings by severity, and each finding with its file and line, a suggested fix as a diff, and Apply fix / Dismiss / Reopen.
A test run as one small tick per test, a row per file: ticks fill as results arrive, the timer, pass and fail counters and the rate roll with the run, and a failing run dims the passes and opens a fix card with a diff that re-runs only what failed.
Security findings ride a metro map from Scan to Triage and branch to Patched, False positive or Needs you; terminal counters roll as dots land, and a finding waiting on you can be patched or dismissed from its card.
An agent working in rounds: a marker runs Work, Check and Improve round a loop, each round leaves a scored chip, and the loop exits to Done at the target or stops at the round limit with the best score and One more round.
A 3-way merge editor: Ours, Base and Theirs panes plus a Result; accept ours, theirs, both or base per conflict, take the agent's suggestion or edit by hand, step through conflicts, then mark the file resolved and complete the merge.
Agents working on their own branches at once and where they get in each other's way: a row per file, a column per agent, a line between agents that changed the same lines, each agent's way in one sentence to pick from, and Merge once everything is settled.
A run as a line of checkpoints, like git for agents: rewind to any of them and the new attempt branches out in its own lane, while the one it left fades back but stays.
Every checkpoint of a run in a side list grouped by date, or as the terminal picker you open with Esc Esc, both driven from the keyboard.
A quiet divider between chat turns that marks a checkpoint; on hover it offers Restore files, Rewind conversation, both or Fork, and says why restore is blocked while the agent runs.
What a restore did: progress while files are written, a done toast with an undo window that runs out, a partial result that names what failed, or a failure that changed nothing.
Forked checkpoints as an indented tree: every rewind opens a fork under the checkpoint it came from, folds to a count, and the path to the head stays solid.
A thumbnail per checkpoint on a track you can scrub: drag the playhead or use the arrow keys to step through the run, then restore the frame you stopped on.
The agent's steps as a vertical stepper you can walk back down and up again; a step that can't be taken back locks every rung under it.
Before a restore runs: the files it rewrites, brings back or removes with their line counts, the turns it rewinds, then Restore and a second, explicit confirm.
Stop, steer and queue a running agent – the answer streams with a caret, a steer lands mid-sentence as a pill, a queued message runs next, and a stopped run resumes from its word.
A label with light passing over it while the agent works: a sweep, a calm band, a pulse or an ASCII scan; it stops when the run ends and dims when it stalls.
The verb that says what the agent is doing, rotating through a verb pack while it works and settling into the past tense when it finishes.
How long the agent has worked, without the time it spent waiting for you: units, a clock, a past-tense summary or a meter with tokens, speed and cost.
Streamed text arriving: tokens fade in, words un-blur, a typewriter or instant, with a bar, block or underscore caret that leaves when the stream ends.
Text that arrives word by word or letter by letter, each piece rising out of a clip and a soft blur as it comes into view, on a capped stagger.
A section title that comes in as it scrolls into view: blur, word, line, tracking or wipe; once, or again on every entry with a quick fade out.
A label morphing into its next state letter by letter: letters matched by character and occurrence stay, new ones stagger in from a blur, removed ones fade out.
Ongoing work shown as a calm band of light across the words while active, one pass per duration with a pause between passes; a changed label rises in.
Text and numbers that spin into their new value on reels stopping left to right, with a soft landing, speed blur, and reels that grow in or collapse when the length changes.
An 'agent is writing here' pass: a soft band of light sweeps down the region being changed, each row it crosses blurs out its old value and settles into the new one, and the footer counts the changes with Undo.