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.
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.
Replays a multi-agent run on one clock: a row per agent, links where work passes between them, and a playhead sweeping over thinking, tool and idle spans as the totals for time, tokens and spend tick up.
One model at a glance: inputs, outputs, context and prices swap in place when you change model, a volume slider turns prices into a monthly bill, benchmark rows rank it, and Compare sets a rival beside it and ticks the stronger figure.
A small automation on a single rail: new mail in Gmail starts it, Claude decides, a branch splits it, and Slack or Linear act; Test run walks the rail and unfolds what each step produced. New steps are picked from a searchable menu of apps.
Four variations grow out of a grid of dots: first a ripple, then a halftone in the colours to come, then a soft focus that resolves. Pick one from the strip, then upscale it, vary it or save it.
Listen to an AI answer: the reply's action row becomes a small player (play, a seek bar, speed, voice) while the word being spoken is lit up in the text.
Notes written from a call: after a brief pass the summary, the decisions and the to-dos arrive word by word; any line reveals the transcript it came from, and to-dos can be ticked or pushed to Linear or Notion.
Drafts an answer below an incoming email: a quick-reply chip sets the direction, tone and length controls redo it in one fade, and you can edit the result before inserting it.
A help chat where the bot steps aside for a human: a handover card lists what the agent will be told and how long people usually wait, then a teammate arrives and carries on, with a slim trail of each step.
Keeps private details out of a prompt: Scan highlights names, addresses, numbers and cards, Redact replaces them with tokens such as [EMAIL_1] before anything is sent, and the answer is filled back in on return.
Works out what a workload costs per month: change tokens in and out, daily volume and caching, and eight models reorder by price while their bars slide to match the priciest.
Settings for your own API keys: a row per provider with its logo, a masked key, health and last use; peek at a key briefly, copy it, rotate it, or delete it with Undo, and new keys are verified before saving.
Numbers for a reply while it streams: first-token delay, tokens per second (with a tiny trend line), tokens out and spend climb next to the model logo, then freeze and expand into where the time went.
Translate a chat message where it sits: choose a language and each sentence is replaced in turn over a faded original, with the detected language, a switch back to the source text and a note naming the model.
Read a post at three depths (whole text, a summary, or bullet points) with a length setting; the shorter views stream in where the text was, and every bullet links back to its source paragraph.
Hook up the apps an assistant may use, right in the card: each one signs in, does an initial import with a thin progress line, shows the access it received, and can be removed after a second confirming press.
A table column filled in by AI: a single instruction is applied row by row, each cell glows while it is looked up, then shows the answer and where it came from, or a miss you can run again.
Sorts support requests into teams: mail, chat widget, Slack and GitHub issues arrive one by one, a model tags what they want, how they feel and how sure it is, and each lands in a lane; unsure ones wait for a person.
Ask a database a question in plain words: the query the model writes types itself into a panel you can fold, rows are counted while it runs, and the result appears as a bar, line or table view plus one sentence explaining it.
Watch an agent work on a shared doc the way a coworker would: its labelled pointer marks a paragraph and retypes it, adds a new section and corrects a misspelling while a colleague reads along, and every edit stays highlighted until you keep or revert it.
Are the model APIs you rely on up? One row per vendor with its logo, a health word and glyph, median response time and a month of daily ticks; rows with an open problem expand into its timeline, and a ring counts down to the next poll.
Follow a fine-tune from queue to endpoint: loss for training and held-out data is plotted against the full step range (which also shows epoch progress), alongside learning rate, time spent and time left, the latest log lines, Pause, a Cancel that asks twice, and Deploy at the end.
Adjust how a customer reply sounds: two sliders (how formal, how detailed) and three voice chips rework the message; only sentences that changed are swapped, words that are new compared with the draft can be highlighted, and Copy grabs whatever is showing.
Oxyn's own assistant: a soft square head with a glowing bulb on an antenna. Resting it bobs and looks around; it grows a little to hear you, gazes upward while the bulb orbits as it thinks, follows its own pen line as it writes, beams when finished and jolts with a red bulb when something breaks.
A picture coming into being like a diffusion sampler: a coarse block grid in the picture's colours sheds its noise in visible steps over a soft guess that slowly focuses, then a sweep from the top lays down the final sharp result.
A little star glyph that signals machine work: four long points and four short paler ones swell gently when resting, send a wave round while thinking, pulse while writing and draw together when finished, always easing from wherever they were.
Oxyn's pixel robot: it idles, thinks under a bubble of dots, types on a keyboard, raises its arms under stars and crosses its eyes on an error, in sprite steps on a fixed clock, crisp at every whole-pixel scale.
A floating ghost whose scalloped hem ripples as it hovers: it blinks at rest, comes forward to listen, rises and turns translucent under a swirl while thinking, writes with a tiny pen, smiles when done and wobbles on an error.
An isometric cube with three shaded sides and a painted face: it tilts and blinks at rest, turns a quarter at a time while thinking with the face moving to the side in front, prints lines on the floor while writing, and sparkles when done.
Shown when an allowance runs out: how much was used, what Pro costs with a monthly or annual toggle, three things it adds (with the logos of the models it mentions), and a choice of Upgrade or Maybe later, every state the same size.
Both sides win: share your personal link or post it, add friends' addresses as chips, then follow each one from invited to joined to paying while your credit climbs and a bonus tier unlocks.
Tells a team how long their trial has left: a ring empties as days pass, the text says what they would lose, and paying is one press away; it comes as a thin strip, a side panel or a compact header badge that hiding or postponing shrinks it into.
Who is on your site this second: a headcount whose digits roll, a dot map where each new visitor flashes, the busiest pages ranked with bars, and fresh sign-ups and upgrades listed with their country flag.
Small “someone just joined” cards for marketing pages: new trials, upgrades and checked purchases slide in on a timer, pointing at or tabbing into the pile freezes it and spreads it open, and each card can be closed.
Prompt composer with model picker, voice input, app connections and approval request: a scrolling plus menu with Plugins, the orange Unrestricted access chip, recording with a dotted level meter, and a tray with a folder picker and Connect apps.
The model menu of an AI chat – point at a model and its speed, quality and cost dashes fill, switch on extended thinking and its effort unfolds, while the tray rolls the first-token time and price.
The prompt box for an agent, in six layouts: send and stop, queue or steer while it works, model, effort and context in reach, attachments, and a reason when sending is off.
Send, stop, queue and steer in one control, in twelve styles: a progress ring, a queue pill, a split, a steer slide, a status tab, pause and stop, a glyph, voice confirm, an answer card, retry and minimal.
The model menu of an agent app: providers, favourites and recents, search, capability badges, a model that needs a key or is rate limited, Auto routing and a change that waits for the next turn.
How hard the model thinks: signal bars, segments, a slider, chevrons, a menu or a toggle; a change made mid-run applies to the next message.
How full the context window is: a ring, a segmented ring, a bar, a grid, text or a card, warning and critical levels, and a breakdown by system, tools, files and history.
Files and context in the draft: upload rings, ready, reading and failed states with retry, too-large rejections, context chips for files, repos, selections and URLs, and drop zones.
Record a voice message in the composer: permission, live level bars, a timer that counts down near the limit, pause, then play, discard or send.
Speech to text in the field: a mic that listens, interim words in grey that settle when final, inserted at the caret, with cancel and an error state.
Type @ to mention people, files and agents or / for commands: ranked, grouped suggestions at the caret, keyboard picking, and pills for accepted mentions.
Switch the agent between Ask, Plan and Agent: segmented or as a menu, a placeholder that follows the mode, and a change that waits for the next turn while it runs.
How much the agent may do without asking: Read only, Ask before edits, Auto-edit or Full access, with risk levels, a confirm for full access and a workspace ceiling.
Choose which tools the agent may use: grouped switches, group toggles, a filter, and connectors that ask you to sign in first.
Messages typed while the agent works wait above the composer: they send in order as turns end, and each can be sent now, edited, reordered or removed.
Guide a running agent without stopping it: notes queue for its next step and show when picked up, or interrupt the current step.
A message field where a pasted link shimmers while it resolves, then unfurls into a preview card (site, title, description, image) that folds back to an inline link or is removed.
What fills the model's context as a field of cells: hover a part to light it, remove files, and compact the conversation while its cells shimmer and clear.
The context window as 200 cells grouped by category with a threshold row: send, attach and compact show exactly how much still fits, crossing the threshold compacts on its own, and switching models re-scales every cell.
A lightweight editor with markdown shortcuts, a floating toolbar with a link face, a slash menu, its own undo and redo, and clean HTML and Markdown out.
The prompt box of an AI app: / commands and @ mentions as atomic tokens, a model and effort menu, a ring counter near the limit, and a send button that turns into a stop control ringed by the reply's progress.
A model picker in one quiet pill: featured models with a note each, an effort submenu that snaps to levels the model accepts, every other model by provider, and a summary that confirms each change.
Composer attachments as 56 px tiles: queued files land one after another while a ring draws round the uploading tile and a small percent counts up, then blurs away.
How much the agent may do, Ask, Plan, Work or Autoresearch, each with its own shape; Autoresearch takes a time budget from presets or typed minutes.
One comment with replies – an assistant reports what it did, folds open details and answers @mentions.
Comment feed with filters, runnable /edit commands, resolve and a composer.
Streamed answer with source cards, citation chips that preview their source, copy, regenerate, feedback and follow-ups.
An AI answer wired to its sources – point at a citation to light up its sentence and source, click to unfold the quoted passage with the matching words marked.
The quiet bar under an AI message – copy turns into a check, regenerate spins and unfolds a version switcher, thumbs pop and ask why, read aloud becomes a tiny equalizer.
A small working pill for AI replies – an eight-ray spinner and a shimmering label that rolls through phases and settles on a check.
AI working panel with a live timer, searched sources and thinking steps that appear one by one.
AI chat card with a soft gradient glow, suggestions, streaming replies and live voice dictation.
Edit a document with AI in place: select a sentence, ⌘K, pick an action, and the rewrite streams in as a word diff you accept change by change, with undo and ghost-text completions.
Threaded comments with nested replies, reactions, @mentions, edit and delete for your own comments, agent replies, and Resolve, which folds the thread into a chip.
A streamed answer with inline sources, a stacked source list, actions and follow-ups.
The assistant drops an offer into a feed when it notices something: accept runs the steps in place and resolves into a result with Review, Not now opens a snooze menu that folds the card into one line with Undo, and the cross removes it.
A budgeted research run's experiments as shapes in bands of hours: kept, reverted and crashed read at a glance, new ones pop in, and the legend pins one outcome.
Markdown that renders correctly while it streams: held-back partial markers, open code fences that grow, tables that wait for whole rows, a caret, and stop or error states.
The thinking of a reply: a shimmering label counts seconds while the newest lines stream, then it folds to “Thought for 7s” and opens to the steps.
Steps, reasoning, search and coding rows playing in with pending, active, done and failed marks.
Cited sources under an answer: cards stream into reserved slots, the overflow becomes a favicon stack, hover previews the snippet and citations highlight their card.
Feedback on a reply: thumbs that fill, reason chips and a note after thumbs down, a short thank-you that folds away, and Try again when sending fails.
One turn of a conversation: user bubbles, assistant prose with a model mark, copy, regenerate and thumbs, system notes, failed sends and attachments.
The empty state of an AI app: a greeting, starter cards by category with a staggered shuffle, and a composer the cards fill.
A conversation with grouped messages, day separators, reactions, read receipts, typing and a composer; agents join with their identity hue.
A full AI chat block: a user turn, the assistant thinking, searching and streaming a cited answer, then actions.
Fields pulled from a document with confidence and page provenance: hover a field to see where it came from, review the low-confidence ones, then confirm.
A deep-research job: phases, the queries it ran, sources rolling in, progress and elapsed time, ending on a report.
A suggestion with its reason, confidence, impact and evidence, accepted or dismissed with Undo.
What the agent used, with kind icons and token cost; pin to keep, remove to drop.
On or off for things that apply right away: a label and second line, at the start or across a settings row, a thumb that stretches as you press it, a pending state and a restart note.
A real checkbox with a label and second line, an indeterminate state for Select all, an error, a card row and a check that draws itself.
Pick one: a list, cards or an inline row, with descriptions and options that are disabled with a reason.
Switch between two to six options: a raised pill or underline that glides and can be dragged across, with icons, counts and badges.
Pick one option in the text field's look: groups, icons and a second line per option, a gliding highlight, type-ahead, search and a loading state.
One value or a range, with marks, named detents that pull the thumb, a live cost tag, a vertical form and a value bubble.
One input for every form: label, hint and error in place, prefix and suffix, clear, copy and show-password buttons, and a character count with a soft limit.
The multi-line twin of the text field: grows with the text, a character count, a button for more room and ⌘ Enter to send.
A single-line field with a label, a helper row and an error row that open on a spring; changed words rise in and numbers roll digit by digit.
A multiline field for notes and longer text, with helper and error rows that open on a spring and a count that rolls only the digits that changed.
Inline AI autocomplete: muted ghost text continues your sentence at the caret, Tab turns it solid in place, ⌘→ takes a word, Esc fades it away, and a chip names the model.
A bounded number with steppers that repeat and speed up when held, a strain and a limit note at the edges, typed drafts that spring back to the limit, and digits that roll the way the value moved.
A Figma-style number field: drag the label to scrub with fine and coarse gears, type values with units or arithmetic, wrap rotations, and feel a rubber-band strain at the limits.
A slider that stretches like rubber past its ends and springs back, pushing its icons outward, with a value tag that sways with the thumb's speed and detents it clicks into.
A select whose trigger grows into the list, with one gliding highlight, type-ahead, paging, an automatic search field for long lists and a value that rolls the way you moved.
A generous target for files: rows upload with progress and time left, fail with a reason and Retry, collapse when removed; rejected types and sizes keep their reason; the prompt can fold to a slim bar.
Click or drop a photo onto the avatar to crop it in place with drag, wheel zoom and keys, then upload through a progress ring with clear errors and Retry.
Several values in one field as chips: paste a whole list, a check per value, duplicates flash, Backspace and arrows to edit.
Pick one or many from a searchable, grouped list: chips with avatars, highlighted matches, create-on-the-fly and full keyboard support.
Several values in a compact field: chips that grow in, a rolling +N, drawn checks in the list and a Clear button.
The verification-code field: a gliding focus ring, paste and SMS autofill, a calm shake on errors and a morph into Verified.
A password input whose reveal button slashes the eye with a drawn line, with a Caps Lock warning and a reveal that hides itself again.
A new-password field with a four-segment meter, a rule checklist with remaining counts and a strength word that morphs up or down.
Rename in place: the text becomes a field without moving, saves optimistically with a drawn check, and rolls back with Retry when the save fails.
A phone field with a searchable country picker, formatting as you type and E.164 out; paste an international number and the country follows.
Grouped filters with removable chips, collapsible checkbox groups, Clear all and full keyboard control.
A multi-step setup flow: steps that fill and check off, sliding steps, inline validation, chip and plan fields, a review with Edit links and a success state.
One decision at a time with a rolling step count, a progress bar, sliding steps and a submit button whose width follows its label.
Paste a signature or messy notes and the agent fills a contact form field by field, with confidence, source highlights, review and Undo.
A compact month view for one date: months slide the way you travel, the selection moves between days and arrows skip blocked days.
A field that opens the calendar in a popover; the changed parts of the date roll, and the popover closes just after a pick.
Presets and two months with a hover preview after the first click, comparison with the previous period or year, Apply and Cancel.
A time field with a list at a fixed step; a later time rises in, an earlier one drops, and the list opens on the chosen time.
Spin a 24-hour dial to pick a time and see which team cities are at work; the readout rolls and the sun turns into the moon.
iOS-style wheels for day and time: drag, flick or scroll and it glides onto an entry; quick picks spin every reel.
A row of toggles, single or multiple: one fill glides between options, or each fades in and neighbours join like a formatting toolbar.
Filter chips that morph as you pick them: a check grows in, the label slides, long sets fold behind +N more and selected chips never hide.
Option cards that need more than a label: one ring glides to the selected card, price and description slots, radio keyboard behaviour.
Capture a numeric opinion: stars as a radio group with half steps, scrubbing, clearing and a value word that rolls.
Reorder by dragging the grip or with arrow keys: rows lift, neighbours slide and the position number rolls.
Acknowledge in one tap: reaction pills whose counts roll, your own highlighted, and a picker tray that grows out of the add button.
A launch countdown with digits that roll per unit, a compact one-line variant, hours absorbing days when days are hidden, and a live state with a pulsing dot at zero.
A total that moves clearly: a label, prefix and suffix, fixed decimals and thousands separators, each digit column rolling the direction the number moved with a slight stagger.
A collapsible JSON tree with search, paging for long arrays, copy value or path, the current path under the tree and full keyboard moves.
A word-level diff for prose: removed words struck through, added words underlined, as one redline paragraph, a before line over an after line, or the new text alone.
Row-level changes in a keyed table (settings, records, environment variables): added, removed and changed rows with before → after and per-kind counts.
Two images under one divider to see what changed: drag anywhere, arrow keys and Home / End, double-click to recentre; plus side by side, onion skin and a difference blend.
A value against a known range as a ring that fills once, springs to new values while the percent rolls, and changes tone and caption exactly at its thresholds.
What fills an allowance: segments that grow in, a hatched overage past the limit, a badge that warns when almost full, and a legend you can pin.
One 100 % bar split into shares: rest on a segment to widen it and read its figures, switch segments from the legend and the rest reflow, with labels inside or on leader lines.
A year of activity as week columns in five levels, with a day tooltip, year navigation and a compact strip for overview cards.
Daily tokens as an area with the cached share as a line: hover any day for its numbers, switch the range and the totals roll.
What background subagents spend checking in: re-reading the whole transcript every poll against a status ping, and how much of the limit that buys back.
A small status label that carries the colour: six tones plus four agent-state tones, soft, outline, solid or mono, a dot, a live dot that pulses and a count up to 99+.
A static, toggle or removable chip with a count and a status dot.
An inline value in a sentence ("7 days") with a tone and an optional delta arrow that knows whether up is good.
A named thing inside a sentence, with a monogram on a colour of its own, a status dot and a hover card.
Initials on a colour of their own, a pixel mark for agents with a ring that follows the agent state, presence, a model badge, a progress ring and an overlapping group with +N.
A key chip for shortcuts: ⌘ on a Mac and Ctrl elsewhere from one Mod key, sequences, keycap, flat and inline styles and a pressed state.
A thin line between groups: across or upright, a word in the middle, dashed, faded ends or inset.
Numbers that roll digit by digit like an odometer, or count up through the values in between; new columns slide in.
Like, comment, repost and share in one pill: icons pop and fill, counts roll in digit by digit.
What a list or panel shows while it has nothing yet: an icon, a title, one line and a first step, framed, bare or inline, with starter prompts for agent apps.
Code with a filename header, light highlighting, copy, wrap and Show all, line numbers, highlighted lines, diffs and a streaming caret.
An app sidebar: brand, sections with nested groups, pinned pages, settings and the account; folds to an icon rail.
A workspace sidebar: switcher, live search, reorderable favourites, inline new projects, a storage meter and the account.
A resizable sidebar that snaps to a 64 px icon rail, with a keyboard splitter and a breadcrumb that follows the page.
Terminal tabs: add, close, rename, cycle with Ctrl+Tab, activity dots on background tabs and exit codes.
Grouped sidebar links with a sliding active indicator, collapsible groups and badges.
Publish in a document toolbar opens a popover that slides out of the button: page address, who can open it, a host with its official mark and two switches; publishing walks through upload, build and live, then shows the link with Copy, views and Unpublish.
A small label for one control: shows after a short rest and at once on keyboard focus, neighbours follow instantly, a shortcut inside, a rich form with a title.
A small floating card attached to its trigger: a title and quiet line, any content, an arrow, opened by press or hover intent; Escape and a press outside close it.
Actions and choices behind any trigger: icons, shortcuts, checks and radios, red items and submenus, a gliding highlight, type-ahead, search and a context-menu mode.
Search and run anything from one field: every word must match, matched letters in medium weight, a gliding highlight, Tab jumps sections. The menu variant adds tool logos, ⌘1–⌘5 and a tray.
A ⌘K palette with an AI mode: search pages and actions, or press Tab to ask; the answer streams in place with numbered sources and next steps you can run, and the palette never changes size.
One search card for an app or docs: grouped results as you type, an Ask AI row first; Tab streams a short answer whose numbered citations light their result below.
Workspace settings on one page: the search grows into a palette that flies to any setting (the row breathes twice), and an unsaved-changes bar counts edits, validates, saves or retries.
A search input whose clear button scales in inside a reserved slot so the width never shifts; with items it filters live under a gliding highlight and shows an empty state.
An icon that morphs into a search field with grouped, highlighted results beneath; the panel tracks the field's width; Enter picks and folds it back.
Record a key combination into caps: held modifiers show as you build it, reserved and taken shortcuts ask first, plus a searchable cheatsheet that lights held keys.
Previous and next around a sliding five-page window with a travelling current mark; numbers slide like a belt when the window shifts. Oxyn adds ellipsis, cursor, load-more and page sizes.
Peer views of one thing: a pill or underline that glides between tabs, panels that slide the way you moved, overflow edge buttons, counts that roll, and closable terminal tabs.
Where a page sits: links from the root to the current page, new crumbs sliding in from a blur, and an optional “…” that folds the middle.
Supporting detail revealed in place: the panel height grows while the answer slides down out of a blur, the chevron springs.
Trade space between panes by dragging or with the keyboard: rubber-band limits, squeezed content fades, collapsible panes leave a restore tab.
A temporary side surface built on the sheet: titled header that doubles as the drag handle, flick or drag past a third to close, any edge.
Nested folders with keyboard navigation, rows that stagger in when a folder opens, guide lines and git or agent status badges.
Contents that read along with you: a line fills through the headings, a marker rides to the current section and the time left rolls down to Finished.
A project header that folds into a compact bar as the page scrolls, with breadcrumb, actions and tabs whose counts roll.
A floating tool dock: a label glides between items, a tint springs to the chosen tool, groups grow a tray and items reorder with Alt + arrows.
Long text clamped to a few lines with a soft fade; Read more glides open, Show less closes, and the toggle only appears when the text overflows.
Your account behind the avatar: identity, a few links, an inline theme and status switch that keep the menu open, usage, and sign out with a spinner.
A workspace switcher like Linear or Slack: the current tile and plan, search, roles, ⌘1–9, inline create and join, and a shimmering switch.
Preview a person, agent or source on hover or focus: a short delay, a grace period while you travel into it, and a fast warm re-open.
Fourteen text-glyph loaders (braille, sand, blocks, scanner…) that settle into a check, a warning or a cross when the agent finishes, waits or fails. One table each, phase-locked to a shared clock.
A dot and a label for any of the 13 agent states, as a pill, inline or a dot alone; the verb comes from a verb pack and stalls show how long.
A small turning arc for work that runs right now, plus dots, ray and orbit styles; any size, speed and arc length, announced only when it has a label.
A pixel-grid loader with a shimmering verb and the elapsed time: drive, dots, orbit or surfer.
When a long task finishes, two rings leave its status mark and roll across the panel, the mark becomes a check and a line says how long it took; a failure sends one short red pulse, and reduced motion swaps the rings for a still halo.
Calm toasts from anywhere: a stack that fans out on hover, promise toasts that morph from spinner to check, a timer hairline that pauses while you read, swipe or Escape to dismiss.
Notice cards stacked behind each other: dismiss the front one to reveal the next. Oxyn adds stack depth, priority ordering, an Undo and background patterns.
A persistent message that helps people recover or continue: tone icon, title and details; dismissing collapses its height; tone and copy changes morph in place.
Grey shapes the size of what they stand in for, one sheen sweeping across all of them in step (or a staggered pulse), shown only after a short delay, then a crossfade into the content.
Loading skeletons that grow into the real content block by block: each placeholder stretches to the content's box while it fades and the content sharpens out of a blur.
A home for updates: unread badge, All and Unread views, grouped rows that expand in place, mark all read and clear, with a bell that tilts.
A useful next step when there is nothing to show: first run, no results, no runs, inbox zero, offline, error and no access.
A dense card that gives itself more room on request: width and height morph together, details fade in after the box has made room, Escape closes from inside.
A modal window on a dimmed backdrop: title and quiet line, a body that scrolls under a fixed header and footer, Escape and backdrop close, focus kept inside and handed back.
The dialog docked to an edge for inspectors and run details: slides in from its side, a drag handle to fling it away, an inset floating style and a pinned footer.
Nested sheets with depth: a new sheet rises while the one below scales back 5 %, dims and peeks; back names the sheet below; drag or fling the top one away; stacked dialogs on wide screens.
A sheet that rests at a peek or full height and follows your finger: rubber-bands past the top, projects a flick to the nearest detent, and the backdrop dims with its height.
A content card with media, byline, status and an action that opens into a quick look; hover lifts it and zooms the media; status changes roll in word by word.
Native scrolling with thin overlay scrollbars and edge fades that grow with what's left; Oxyn's stick-to-bottom follows a streaming transcript and offers Jump to latest when you scroll up.
Workspace quick settings: tiles that open into detail, a session dial that counts past twelve and snaps to 5 minutes, and meters that follow the pointer with rubber-banded ends.
An action label that swaps to its next state while keeping its place: a working phase (pending label or a round spinner), a failure label, tones, and holds that advance on their own.
A pill that confirms by splitting: it stretches with a small overshoot, a check bubble pinches off its end and the label turns to the past tense; the bubble is Undo for four seconds, and a failure shakes once with a cross and Try again.
A Give to your agent split button: the main part copies an agent-ready hand-off for the chosen coding agent, the chevron picks the agent (official marks) and the format (prompt, skill file, install command), and the preview shows exactly what is copied.
Eight variants and five sizes, with a shimmering loading state, a progress fill, press-and-hold for destructive actions and a shortcut chip.
A square button that is only an icon: ghost, secondary or primary, five sizes, a toggle that morphs its icon, a dot or count badge.
A button that runs something and reports back: idle, pending with a spinner, a check on success, an error that retries with back-off.
A main action with a menu of alternatives; it can remember the last choice and promote it to the main half.
Joined buttons for a toolbar: outline or solid, horizontal or vertical, icon-only with tooltips, a toggle selection and an overflow menu.
The quiet tray under a message: a highlight that glides between buttons as a pill, underline or glow, and a tray that can hide when idle.
Icon buttons that open into labels one at a time, then confirm in place (Copy → Copied).
Copy a value with immediate confirmation: icon and label crossfade to Copied, the check draws in, and it resets after a moment.
A card with the effort's name and what it does over a dense tick ruler: the ticks behind the capsule knob tint toward it, the knob snaps to the levels, and reset goes back to the default.
A model's details with a notched reasoning slider (R steps it; Max fills the bar with red dots), a Fast mode switch (F) and a Favorite button.
A chip with the current effort that opens a plain list of levels above it, the chosen one checked.
A “Select effort” pill that opens a popover with the level, the model it applies to, a dotted step slider and reset.
One model chip whose dropdown sets both the context window (1M tagged “Higher usage”) and the effort, in two radio groups.
Models listed with their effort as a suffix; hovering or → opens a cascading submenu that sets that model’s effort.
An Oxyn original after the user's reference: even thin lines in a steel-blue to coral to periwinkle gradient; a solid nozzle in the colour under it slides along and snaps to the levels. Tone red keeps the all-red look.
An Oxyn original: one rising bar per level, lit up to the chosen one (the top in red); pointing at a bar previews its thinking budget and wait.
The context window as one stacked bar or a field of dots, with a legend that lights each kind and a Compact / Undo button.
What fills the window as a list of kinds with their share; open one to see its files, tools or turns and unload what you do not need.
An Oxyn original: the window as a pile of slabs under the line where it compacts by itself; each turn thickens the chat until it is pressed into a summary.
An Oxyn original: a tall glass whose water is the used share, with marks at 75 % and at the compaction line; turns raise it and Compact drains it.
Disk use as a capacity bar of dots, one colour block per category, over a category grid; point or click for details, Rescan, and clear caches or the Trash from the hint.
Skills and commands that ride along with each new chat, filtered by how long they sat unused; tick some, watch the tokens they free as dots, move them to the Trash and undo.
An Oxyn original: the disk as 200 dots, half a percent each; a Win back lens keeps only what can be cleared lit.
An Oxyn original: a fortnight of dot columns lit to each day's use, then ghost columns at the current pace up to the day the disk is full.
Drag a file into the box to upload it – a progress bar and percent, then Uploaded; one over the limit is refused in red. Real file-type icons on every file.
Files on their way into a prompt: a ring of progress round each icon, then type and size; failed uploads offer Retry, files over the limit stay red, and extras fold into +N.
An Oxyn original: image attachments as a little stack of prints that fans out when you point at it; press one to bring it forward, take any out.
An Oxyn original: one drop target that splits into where a file should go – this message, the project's files or a style reference.
A composer whose attach drop-up and model menu both pour out of its top edge above their buttons – the shared gooey motion on a real prompt box.
A + button whose drop-up – PDF, Image, Excel, Doc, Slides, Code, Drive, GitHub – pours out of it like liquid and runs back in when it closes.
A model chip whose list – each model with its maker's mark – pours out of its corner like liquid; the chosen name blurs into the chip.
An Oxyn original: a segmented control whose ink pill moves like a drop, trailing a droplet that is pulled back in when it lands.
An Oxyn original: a round + button whose actions drip out one after another and flow back in when it closes.
Picture tiles we draw ourselves plus Your own, with Film, Static or Dither laid over the picture and a home screen preview.
Eight mini-window swatches – System split corner to corner, Light, Dark, four tinted darks and Contrast – with a Font size menu and a live sample.
Oxyn original: the theme in use and a candidate over one sample window, a divider you drag between them, then Use to swap.
Oxyn original: accent, row spacing and corner shape beside a settings sample that takes each at once.
Oxyn original: Light, Dark, Sun or your own hours on a 24-hour strip; drag along it to preview the day and the sample turns with it.
Oxyn original: Sans, Serif or Mono, A− / A+ around a stepped size slider and three line spacings, on a reading sample that counts its line length.
Oxyn original: drag a lamp over a small interface and its cards cast shadows away from it, or glow on the side that faces it.
Oxyn original: six alternate icons we draw, in Colour, Dark or one Tinted hue, shown in a home row among other apps.
Oxyn original: Increase contrast, Reduce motion, Reduce transparency and Bold text beside a sample that takes each at once.