Everything we've shipped lately.

A board tells you where a card stands and nothing about whether anyone is still standing near it: a card with a live thread and one nobody has touched since August wear the same face. Each card now has a temperature, read from two things — how recently anything happened to it (its last edit or move, its newest comment, its last agent pickup) and how much has piled up on it (comments, files, sketches and linked code count in full; subtasks, assignees, bundles and tables count half). It cools the way a body does: a bare card is hot for a day, warm for a week, then cold; a busy card starts hotter and cools slower. Only the two ends wear a chip — a flame for Hot, a snowflake for Cold — because a chip on every card would be noise. The flame in the bottom bar, or the letter t, orders every column hottest first; in the list view the same key sorts the sheet by temperature. It is your lens, not the board’s order: it rides the URL, is remembered per board and never rewrites where anyone dragged a card — and while it is on, cards can’t be dragged, so a private order can never become the anchors a drop is measured against. Move from the card menu still works, and a pinned card keeps the head of its lane.

A column header that sorts is a promise about the table, and this one only ever ordered the rows that had already arrived. On five thousand records paged a hundred at a time, the “smallest” value it showed you was the smallest of an arbitrary hundred — the footer admitted as much, in small type, which is not the same as being right. The order is the database’s now, and paging goes with it: the page you land on when you sort is genuinely the first page of the whole table, and the next one continues it. Empty cells sort last whichever direction you pick, and they count as empty all four ways a cell can be blank. Re-sorting returns you to the first page rather than carrying you to a place that no longer exists.

A team’s DeepSeek or Cline agent is set up by the team’s owners, usable by everyone in the team, and reachable only by putting its tag on a card. The tags field suggested agents you own — so the one tag a member most needed was the one it would never show them, learnable in a meeting and nowhere else. The field now suggests every agent you can send work to, which is the question it was always asking. An agent that is switched off stays in the list on purpose: the tag is how a card is addressed, and a card addressed to a sleeping agent gets picked up when it wakes. The menu’s footer no longer claims these are all yours, because now some of them are not.

Scheduling a card to be picked up starts a Claude session — that is all that path has ever known how to start. It never checked which agent the schedule named, so a point set against a team’s DeepSeek or Cline agent quietly ran as Claude instead: the wrong model, someone else’s account, and a run that looked entirely successful, which is why nobody noticed. It refuses now, and names the lane it refused. When you set the schedule it is a rejected form, because you can still pick another agent; when a schedule that already exists comes due, it is a blocked run naming the lane, because a standing appointment doing the wrong thing every morning is worse than one that stops. Both point at the door that works: tag the card, and that agent takes it.

A listener on a single bare letter is a claim on that letter everywhere, and “d” is one people type. Anywhere a keystroke landed without a real input focused — a board, a chat page, a deck — pressing it swung the entire product between light and dark, which is a loud answer to a key meant for something else. The hotkey is gone; the toggle in the menu stays exactly where it was. Everything that advertised the shortcut went with it, since a removed binding that is still promised is worse than one that merely surprises you: the shortcuts dialog, the marketing page, and the reservation that stopped the call from giving the letter to anything more useful.

Everything owned by a team said so with the word “Team”. On a wall where most things belong to some team, that is a word every card wears and none of them is identified by — two teams a hue apart were indistinguishable at a glance. A team-scoped row now wears the same avatar-and-colour chip the navbar and search results use: the team’s own tile and its name, tinted its colour. Personal and shared keep the lock and the globe, which really are the whole answer for them. Where a full badge will not fit — a table cell beside a title, the sidebar rail, a filter menu — the tile goes in alone at a size meant to be recognised rather than read. It covers the workspace cards, the container grid and table, the sidebar, the content sheet and the knowledge bundles.

Writing what is said into the chat panel was on by default, on the reasoning that if the words are being written down anyway, the panel is where people already are. What it actually did to anyone who had not asked for it was bury their chat under a running transcript of the call they were sitting in — and chat is where people say the thing they did not want to say out loud. It is off now unless you turn it on, and remembered for you alone. The care is in the reading: the old default wrote nothing for everyone who was happy with it, so treating a missing preference as “on” would have kept it on for exactly the people who never chose it. Nobody-has-asked means off. The transcript still has a pane of its own.

A team wanted a deck its members could vote in, and the nearest thing available did the one thing a poll must never do: a decision deck answers once and the last word wins, so the second voter erased the first and the deck reported whoever clicked last as the will of the room. A poll deck keeps one vote per person, changeable, every vote counted and on the record. Each question shows its tally as it fills, including the options nobody picked, because “nothing” is a result. A tie leads jointly and is reported as a tie — picking one of them to print is exactly the failure this exists to avoid. A vote for an option the author has since deleted is counted apart rather than dropped or quietly folded in, and an agent may not vote in a count of the team.

Asking a five-thousand-row table “how many of each status?” through an agent meant paging the whole thing: a hundred records a call, fifty-two calls, every one of them carrying the full record, to arrive at four integers. The first page alone came back at 169KB, so on a table that size the question did not fit in the agent’s head and the tally never got made. There is a tool for the question now, and the database answers it: group by one field for a breakdown, two for a cross-tab, none for a single total, with sums, averages and distinct counts along for the ride. A shortened list still reports how many groups and rows there really were, and the filters are the same ones a search uses — so a filtered count and a filtered page can never describe different rows while looking like they describe the same ones.

Filtering the content sheet to decks showed 32 of the 149 you could see next door, with the newest ones simply absent and no hint why. The sheet lists things filed in a databank, and a deck nobody filed has no row here and never will — so the two pages were counting different things and neither said so. The sheet did have the explanation, thirty-two rows further down where the pager covers it. It now sits above the list it is about, under the filter chips, with both halves of the arithmetic: this sheet lists the 32 decks filed in a databank, and 117 more are not filed in one. A deck row also stopped being a title and a dash — it carries its own measure in its own noun now: 12 slides, 48 cards, 6 pages, 4 of 12 decided.

The grid could search every text field at once and that was the whole of it — no way to put a question to a single column, and no way at all to ask it for two answers, which is what “show me the suspect and the infected” needs. There is a Filters button beside Columns now, on the reading that the two are the same kind of knob: one says which fields you see, the other which rows. A column with a fixed set of answers offers them as a tick list; an open-ended one gets a contains box instead, because a checkbox list of five thousand company names is not a filter, it is the table again. What you set shows as removable chips, and it runs over the whole table rather than the page that happened to load. The filters live in the URL, so a filtered grid is a link you can send.

A grid truncates, and it should — a column widened to its longest value pushes every other column off the screen. But there was no way to read what it cut, so a note ended mid-word at “de sub…” and a scraped JSON blob was worse than truncated, because stored on one line it is unreadable at any width. Any cell with something in it now opens on a click and shows what it holds: prose wrapped and whole, JSON indented and coloured, with the character count, the line count and a copy button. The expand control appears on the cell under your cursor and on keyboard focus, which is the half a hover-only affordance forgets. Text that merely looks like JSON — a blob cut off mid-write — is shown as the broken text it is rather than silently repaired.

Dragging a card onto the board’s final column answered “The taskboard changed. Reload and try again” and dropped nothing — and reloading could never have helped, because what that column is missing is not stale, it is hidden on purpose. That lane arrives with every top-level card idle past a day already removed, so it renders short over a longer one and often looks empty above one holding fourteen cards. The drop reports the cards either side of your cursor, the move insists those two be genuinely next to each other, and across a hidden card they never are. The move now works that out for itself against the full lane it is the only one holding: a card dropped below the last one on screen lands below that card, and onto a column that looks empty it lands at the foot of the real one.

You could sort the workspace index by “Last touched” and then find that neither date appeared anywhere on the card — the sort order was the only place the fact ever surfaced, which makes it something you can rank by and never read. Every workspace card carries a second footer line now, in the narrow relative style the databank cards use: created Jul 23, updated 2h ago. Hover either and you get the full timestamp. The workspace page repeats both in full under its description, since that is the page you land on when what you actually want to know is whether the data in front of you is still current.

Someone pasted shapes out of Excalidraw into a call’s chat and the thread received what Excalidraw puts on the clipboard — its scene as text, several screens of coordinates where a drawing was meant. The composer learned to turn that paste into a picture the day after, but every message already sent was still a wall of numbers, and a client that pastes without that help still sends one. So the reader draws it. A message whose body parses as a drawing is rendered as the drawing, sized to the bubble, in the team chat thread and in the in-call chat alike. Ordinary messages pay two string checks and never load the drawing engine at all.

Book time with someone through their availability and the meeting appeared on their calendar, not yours — you were text in the description of an event you could not see, and the only way back to it was the link in your email. A booking now names you as an attendee of the event, by account when you are signed in or have one, by address when you are not. The calendar then reads the events that name you on calendars you cannot otherwise see and files them under one calendar called Invitations: never writable, listed only while something is on it, and coloured its own amber so an invitation never reads as one of your own events or a team’s. Cancel the booking and the invitation goes with the host’s event.

The call had one way to veil your camera, and it was the loud one — blockify, which turns you into moving squares. This is its gentler sibling. Blur rides the same setting, so every client shows the owner’s camera veiled, your own tile included, and a client too old to know the word shows the clear picture, which is the honest way to degrade: a veil is expression, not privacy. It needs no second video track and no canvas, just the tile’s own picture blurred and scaled past its edges so there is no soft border to give it away. Your name, your avatar and the focus toggle stay crisp — the filter is on the video, not the tile. Toggle it beside Blockify in the call menu; one veil at a time.

Opening a deck in the databank’s preview pane put nothing in your history, which on a phone is the whole problem: Back left the databank altogether instead of closing the pane you had open, and the address bar still said the page you started on, so there was nothing to send anyone or return to. The pane is part of the URL now. Opening one adds a history entry, so Back closes it. Stepping through with the arrows replaces that entry rather than stacking it — fifty arrows are one Back, not fifty. Closing it from the pane’s own chrome pops the entry it pushed, so your history never holds a pane that is already shut. Load a link with a pane in it and the object opens as soon as the page knows about it.

The deck’s Fullscreen button did nothing at all on an iPhone, and not by accident — iOS implements the fullscreen request for video only, and every browser on the device is Safari underneath, so the call was either missing or refused and the failure went quietly into a catch. The deck asks for real fullscreen wherever real fullscreen exists, and otherwise draws it: the deck pinned over the viewport, the page behind it locked, Escape leaving it, and Back leaving it too — because on a phone the gesture people actually reach for is the swipe. A browser that has the method and refuses it falls through to the drawn version rather than to a dead button. The pager, the slide count and the outline all survive into it exactly as they do natively.

The coms button and the navbar bell rang for as long as any joinable call was live, on every page you visited, with no way to say “I know, not now” short of joining or waiting it out. Every live-call row now carries a bell: stop ringing for this call, or ring again. A silenced call keeps its row, because it is still one you can walk into — it just stops swelling the halo, rocking the handsets and lighting up the team marks. The scope is deliberately the smallest one that answers the ask: this call, until it ends, on this device. Not “never ring for this team”, which would be a durable setting with an un-mute surface people forget exists.

Two things the call painted over that it had no business painting over. In a short window, the bottom row of camera tiles put its names and mute icons exactly where the controls pill floats, so the person you were looking at had a button over their name — the focus layouts had always kept a band clear top and bottom, and the gallery and speaker grids simply filled the stage edge to edge. They keep the same band now, and the speaker layout’s view of yourself sits inside it rather than on the call’s own search button. Separately, on a wide call page the expanded call layer sliced the team badge in the navbar in half, because the badge deliberately overhangs the header’s bottom edge and the layer started exactly there, one stacking tier above it. It sits a tier below now.

Handing a card to Claude Code or Codex gave the agent the card’s title and description and then stopped — so the agent narrated its progress into its own terminal, and the card stayed silent until somebody thought to go and ask. The prompt now closes with two standing requests: post progress as comments on the card as you go, saying what you found, what you changed and what is blocking you, and when you finish, record the result and link the commit or pull request. Both are named by the tool that does them, because “keep the task updated” on its own leaves an agent guessing which of nearly two hundred tools you meant.

The model picker rendered its shortlist as one flat list in cost order, so on the agent actually called DeepSeek the first six rows were a router id and five free models from other vendors, and DeepSeek’s own models came last. The list has not changed; it reads in groups now, taken from the model ids the same way the route badge already reads them — DeepSeek direct first, DeepSeek via OpenRouter under it, then the free pool and the other vendors. The lane’s default is still the first row, since that is what choosing nothing has always meant, and arrowing through the list skips the headings rather than landing on them.

Every Save on a team agent had been refused since the MCP profile feature landed, with a validation error about a string that was undefined — from the settings page and from the team overview, on all three of the DeepSeek, Cline and Codex panels. The routes had started requiring a profile name, and not one of the three panels has a field for it, so not one of them ever sent it. The profile is optional on save now: leaving it out leaves whatever profile is stored exactly as it is, clearing it deliberately still clears it, and a name that matches no profile is still refused. The panels are unchanged — a save from a form with no profile field must not silently wipe one set elsewhere.

The preview pane’s Open card button took you to the taskboard and left you there: the board loaded with nothing open and you had to find the card again by eye, which on a full board is the search you clicked the button to avoid. A task row’s own link did the same thing. Both now carry the card with them, using the parameter the board already understands for opening one directly. A link that has somehow lost its card still falls back to the board, on the grounds that the board is better than nowhere.

The room behind a meeting link had the team call's face and a fraction of its functions: mic, camera, screen, a stock chat and Leave, on a grid that never changed shape. It is now built from the call's own parts. Click a face to put it on the stage and click it again to put it down; a shared screen takes the room and everyone else moves to the filmstrip, a deck or a sketch sits in the mosaic as a tile you can focus, and Show all at the end of the strip is the way back. Blockify or blur your camera, adjust its zoom or switch lenses, and the room tells you when you are talking into a muted mic. The pill is the call's, with the ⋯ sheet listing everything the room can do, the ⌘K menu to search it, and the same bare keys — M, C, S, H, A and the rest. Chat has the call's bubbles and an unread count; an activity feed keeps who came, who left and what was shared while you were looking elsewhere. Your camera comes on when you join, as on a call, and falls back politely when it can't. A host can end the meeting for everyone. What is still a call's alone is one short list: live captions, the team's escalations, and minimizing into an app the page does not have.

A public meeting link treated everyone who opened it as a stranger — including the people it was made for. A teammate who clicked the link from a chat, in a browser with no session, was asked to type a name and wait to be let into their own team's meeting. The door now offers a sign-in under the knock form. Sign in and you land back on the same door: if the meeting is on a calendar you can see, it says Join and you walk straight in; if it is not, you still knock, but under the name on your account rather than one you typed. A visitor who is already signed in is never shown the offer.

A live invite with nothing left to offer said the same thing every time — every time on this invite is now taken — and that is only true in one of the three ways an invite can run dry. Your calendar may cover every start on offer; the last one may simply have passed inside the notice you asked for; or no window you wrote down was ever long enough to hold the meeting. The door names which one, and it reads the clock before the calendar, because telling somebody a time is taken when they were only too late is both wrong and nothing they can act on. The half that was missing entirely was yours: an open invite offering nothing now warns on your own card and names the meeting standing in the way by its title. Your guest still learns the shape of the problem and never whose meeting it is.

An invite link gets opened on a phone more than anywhere else, and it laid its times out one full-width button per row — six of them were a page of scrolling before you could compare any two. They sit two across on a phone now, three from a tablet up, with the time you pick spanning the full width so that choosing and then committing stays the same two steps it always was. The booking page keeps its single column, because a rail beside a month grid has room for nothing else. Two more shared doors got the same attention: the page your guest is likeliest to have kept — the one their booking lives at — now leads with Join the meeting whenever there is a public room to join, and a share link that used to read http://localh between two buttons takes the whole width with the buttons wrapped underneath.

A pin is the board's opinion. Everyone sees a pinned card float to the top of its column and it stays there for the whole team, so there was no way to say this one is mine to keep an eye on without moving it for everybody else. Star a card now and it lifts out of the lane into a strip above it — above the pinned cards, and only on your screen. Nobody else's board changes. A star never rewrites where the card actually sits, so unstarring drops it back into the exact slot it was lifted out of, and dragging another card into that lane still lands it between the neighbours you can see. Stars follow a card that gets moved to another board, so a teammate reorganising things cannot quietly unstar your work. You can star on a board you are only allowed to read, which is the whole point of a tier that is yours.

Your booking page is a standing door: one address, anyone holding it may book, and only inside the week you normally keep. That is the wrong shape for reaching one named person outside your company. An invite is the addressed half — one link for one person, offering only the times you wrote down by hand, settling into exactly one meeting. There is no mode to pick, because the length of a time you offer decides how it reads: one exactly as long as the meeting is take it or leave it, a longer one lets them choose from inside it, and several are options. Your usual working hours do not get to delete the Saturday you deliberately offered a client, though your calendar still does, so an invite and a page booking can never claim the same slot. Claiming ends in a room they can walk into without an account, and a sketch can stand on that stage now beside a deck.

Two ways the findings board was telling you the wrong thing about your agents. An agent turned away for want of permission was only filed when the refusal happened to be phrased with a contraction: being told it can't edit that databank was recorded every time, while you don't have access to do that — the same refusal in different words — fell through to a generic tool error and was then dropped as noise. A refusal is now read as one however it is worded, and lands on the board named as a permission problem rather than buried. In the other direction, an agent that looked for a file and simply did not find it was raising a finding, but only from an editor or harness session: the check that waves an ordinary miss through knew one spelling of the tool's name and those sessions send another, in lower case. The board now carries what deserves your attention and not the business of looking something up.

Agents have had a way to say “this got in my way” for a while: one call, and a recurring complaint becomes a single card on your findings board that counts up each time it is seen again. But it only answered agents this platform had launched itself, in the auto-agent console. An agent you connect from somewhere else — Claude Code in a terminal, Cursor, a script on your own token — was turned away, which is backwards: those are exactly the sessions nobody here can read, so telling you is the only way you would ever find out. Now they can all file, and a report from your editor lands in the same ledger as one from a console run, so a problem hit in both places reads as one problem seen twice rather than two half-stories. Each card links back to the run that hit it — a console run to its transcript, anything else to its session's activity trail.

Filing something into a databank once needed one tool for each kind of thing you might file — eleven near-identical names whose only real difference was the word for what they took. A single call replaced the lot of them at the start of the month, and the old names stayed on as forwarders for one release so that nothing built against them broke on the day the short one arrived. That release is over and the eleven have been withdrawn as promised. If you wired an agent to one of the long names, point it at the one call and tell it what kind of thing you are filing; every prompt and recipe here has said it that way for a while. The gain is not tidiness. Every agent you connect reads the whole catalogue of tools before it does anything at all, and that catalogue is now some three thousand tokens lighter — a toll each session was paying to be offered names it had already been told not to use.

A team whose mark is a drawing had it painted onto a deck as a background image, and a browser renders an SVG inside an image statically — so a mark meant to animate never moved a stroke, and the only motion was its box sliding into place. The drawing travels with the document now, and on the cover, the sign-off and the sign-off's banner it draws itself: strokes trace out along their own measured length and fills ink in behind them, at the speed your team already chose. The signature yields to the strokes and still writes its name last — freeze a cover mid-draw and the wordmark reads F U S I F with the rest still to come. Ask for less motion and you get the finished mark. A returning reader also stops seeing yesterday's layout: the deck stylesheet is now cached against a hash of its own bytes.

Copying shapes out of Excalidraw puts no picture on your clipboard — it writes the scene out as text, meant for another Excalidraw to read. Paste that into a message box and the thread got a wall of braces and numbers, cut off at the composer's four-thousand-character ceiling, and that is what your drawing looked like to everyone in it. Paste one now and it behaves exactly like a pasted screenshot: it is rendered to a picture and uploaded down the same path, so it shows up as the picture. The scene rides along inside that image, so dropping it back into Excalidraw or onto a sketch opens it as editable shapes again. The first paste in a session loads the drawing engine and tells you it is doing so; every one after it lands in a blink.

On a phone the furniture above a deck came to 264 pixels — 43% of everything under the navbar — and the deck's own minimum height then ran four pixels past the bottom of the screen, so a page that should have fitted had to be scrolled. Two of those bands were saying one fact: a bare creator face wrapped onto its own line in the fact row, and the same companion named in words in a bordered card forty pixels below it. The face now steps aside wherever that run line renders, and under a tablet's width the run line loses its box. A deck with no agent run behind it keeps the face, because there it is the only thing that says who made it. Every fact and both links stay, and from a tablet up the header looks exactly as it did.

Hand a taskboard to a team agent and ask it for a deck, and the errand arrived with no repository wired to it: a deck about a board whose every card names the same codebase was distilled from card titles alone, and the session rail said so in as many words. The errand resolves the repo itself now — the board's own default, or the team's when the team has exactly one — and clones it, so the deck is written from the code as well as from the cards. Two candidates is not a tie to break by guesswork, so an ambiguous board keeps the old no-checkout behaviour. While it works, the agent wears a pulsing initial rather than a grey spinner, and the console rail lists your team's agents instead of staying blank until you pick a session.

A title card with a large mark is a poster, and a poster hangs its mark in the middle — so the cover's square leaves the top-left corner for the centre of the slide, with the title under it, uncovered corner to corner as the slide settles. The banner that runs across every page in between is capped smaller: a wordmark at the old size is read rather than looked at, and it was competing with the title underneath it. The corner counts like a page now, "2 / 7" instead of a bare 2, on a full slide and on a deck's card face alike. The sign-off signs off, mark at the top and slogan beneath. Every animation ends fully open, so a reader who asked for less motion gets the whole mark rather than half of one.

A team's deck style — its wordmark, its slogan, how much it moves — could only be set by hand on the team's settings page, so an agent could write you a deck but never the look it wears. It is settable over MCP now, the same fields the settings page writes, which means the agent that stands a team up can leave it wearing its own house style instead of the default. In the same pass the deck whose every card has a back is called a flip everywhere a reader meets one — the control beside the pager, the verb in the docs — so asking an agent for one by its day-old other name fails loudly rather than quietly handing back a deck with every back face dropped. A stylesheet link written against the old word still resolves.

A simple table counted its own changes and narrated each one, but an edit recorded only which field had moved — never what it had moved from — and the per-record history had nowhere to be read. Every change now keeps the values on both sides and a copy of the whole row as it stood, and the table page itself has the history, not just the chart beside it. From there a row can be put back: pick a point and the old body is replayed against the table as it is today, so a key whose field has since gone is dropped and named, and a restore the table would no longer accept fails instead of being forced through. A row you deleted comes back the same way. A very large edit is still narrated, but marked as something you cannot restore to.

An expanded call put three horizontal bars above the thing you were actually looking at: the call's own title row, then the focused sketch or deck's header, then the filmstrip. On the shape a laptop actually is — wide and short — that is roughly 150 pixels taken out of the one axis a canvas has none of. The focused content's chrome moves up into the call's title bar: save status, who else is drawing, the stop-sharing button for a screen you are sharing, all on a line that was already there, none of them losing what they were wired to. The filmstrip becomes a column beside the stage on a wide screen — the same width at which chat docks to the side — and stays a row underneath on anything narrower.

Drawing on a sketch from a phone worked sideways and not up and down: a downward drag was taken as a pull on the page, so the stroke was cancelled halfway and the browser refreshed the tab under you. Nothing in the app claimed that gesture, and the drawing engine deliberately styles only its own canvas — the rest is the app's to say. It is said now, on the pages that carry a canvas and nowhere else, so pull-to-refresh survives everywhere it is harmless. The full-canvas layer that takes your drag while the pointer highlighter is armed claims touches too, rather than letting them fall through. Rubber-banding and the accidental reload are both gone, and a vertical drag is a line.

The "Needs your attention" panel on a team page opened every waiting page out into its full decision deck. One page with a dozen open decisions is a card as tall as the screen, and this panel is half of a band you scan on your way somewhere else — so the deck pushed the rest of the team below the fold. On the team overview it stays a row list: the page is still there, it says a decision is waiting on you, and the deck is one click away from the row or from your attention page. Where the deck is the point — your own attention page, your dashboard — nothing changed.

One logo was never one logo. A mark has to sit in the corner of a slide at three per cent of it and run across the top of a page at nearly a quarter, and the drawing that survives the first is not the one that carries a name in the second: squeeze a wordmark into a corner and it is a grey smear, stretch an icon across a header and it is a hole. Teams picked whichever hurt less. The slot is part of what a team declares now, and there are two of them. Each takes two uploaded files, one per mode, or — new here — the drawing written out rather than uploaded, which is the only way a mark that recolours itself for a dark slide and a printed sheet keeps doing it. Only the square can still be inferred from your palette; a banner is a drawing of a name, and a palette has no name in it.

A mark on a canvas was reachable only by clicking it in a list you had to already be looking at, so there was no way to hand somebody one. Every row in the marks popover, and the selected mark's own card, now copies a link that opens the sketch already panned to it. It behaves like an anchor rather than a view setting: it fires once, after the canvas knows whether that mark is still there, lands on exactly the pan a click would have made, and stays in the address so a reload lands in the same place. It survives the sign-in redirect too, because where it lands is the entire point of sending it. A mark that has since been deleted says so — and a link that arrives while your tab is still catching up waits for the real record instead of spending its one shot on a stale one.

The pair of buttons at the bottom right of a canvas was written to sit at the same height as the round search button beside it, and says so in a comment. That button rose to the app-wide baseline a month ago so it would clear the toolbars on the timeline and the calendar, and this row did not come with it — 48 pixels too low, down in the corner where the drawing engine paints its own footer and help button. Reported as hiding under the other button, which is exactly what it was doing. It rejoins the baseline, and keeps the extra lift it takes while you are editing on a phone to clear the mobile toolbar, so it still rises together with the chat panel and the follow control instead of drifting apart again.

Editing your team's design system or deck style restyled every deck the team had ever written, last quarter's board pack included — which is what you want for the deck you are working on and the opposite of what you want for the ones already sent. A team deck now carries a copy of both, taken when it was created, and that copy is what the deck, its share links and its cover are drawn from. Moving one forward is a deliberate act: a bar on the deck page, a restyle-all on the team's design page, or asking an agent for it — each an ordinary edit with a restore point, so putting the old look back is the same motion as putting old words back. The platform's own rendering still moves forward for everyone; what is held is your team's side of it.

Every team's first deck-style save failed, and not loudly: the settings page simply went on saying "Unsaved changes." So a team that had not already uploaded a logo could not set a wordmark, a slogan or a motion choice at all. A save carries the version it expects to overwrite, and a team with no deck style yet honestly has version zero — while the check in front of it insisted on a number above zero, which is the one value a first save can possibly send. Zero is a version, not the absence of one, and it goes through now. The workaround, if you hit this: uploading a logo wrote the row through another door and let every later save past, which is why more than one team has a mark on file and none of the words that go with it.

Every deck cover was a broken image. The server was handing over the right bytes everywhere but one place: the build folded two pieces of the drawing together and swallowed the space between two attributes, leaving markup no browser will parse — 944 characters where the same deck drew 946 on a laptop. It could not have been caught before the deploy, because the development server does no folding at all and covers rendered perfectly right up to the moment they were built. That tag is one piece now, with no seam left to lose. In the same pass a collecting deck got its face back where it is filed: the deck index led every kind with a cover while the databank card only drew one for the showing kinds, so the same deck had a cover in one place and not the other.

The control that expands a deck's description sits at the right-hand end of its row on purpose — a row of its own would cost every phone twenty pixels of deck. That is the same edge the feedback tab hangs on, and on a phone held upright the two land on top of each other, so tapping More opened the feedback dialog instead of the description. Height decides it rather than width, which is why a pass on a desktop never saw it and why the same phone turned sideways was fine. The row keeps the tab's lane clear now, measured against the live tab with room to spare even when hovering makes it wider.

The auto-agent console's right rail listed the cache status of every repository you could see, in a narrow column beside a transcript about one run — with the run's own repository fourth down the list, and the question the list was good for (is any cache failing?) unanswerable for a repo you do not own. The rail shows the environment of the session you are looking at and nothing else now, and names the repository and work branch that run is in. The fleet-wide view moves to an admin page of its own, where every repository on the deployment is listed with its cache state, stack, owner, package manager and size, over tiles counting how many are ready, building, stale, failed or have no cache at all. Rebuilding is still done from the rail, one repo at a time; the fleet page only reads.

Asking an agent for your attention items with a small limit could come back empty against a feed with plenty in it: the cut ran a layer below the filters, so a limit of two meant "filter the top two rows of everything" rather than "two that match". The empty answer then guessed at the cause and guessed wrong — it blamed filters that had excluded nothing, and advised narrowing with a filter that was already on. The limit is applied after the filters now, and the reply says how many actually matched beside how many it returned. The three ways a list can come back short — your own limit, the reply's size cap, the scan's own ceiling — are told apart, and each says the thing that helps: raise it, narrow it, or narrow it with the filters only.

A sketch opens fitted to its content, so on a board with a hundred and forty embeds every one of them is on screen and every one mounts in the same frame — each asking the server to resize its picture, all at once, behind the browser's own limit on how many requests it will run at a time. No amount of tuning what counts as near the viewport helps when everything is already inside it. So mounting is rate-limited instead: twenty-four at a time, ordered by distance from the middle of the screen because that is where you are already looking, and another twenty-four every quarter second. Everything still mounts, over about a second rather than in one lump; nothing already up is dropped to make room, and a board under the budget pays nothing at all.

Everywhere else a team appears it draws its own mark — the avatar it uploaded, or its initials on its own gradient. The picker you use when creating a board drew the same generic group glyph for all of them, so the one screen whose whole job is choosing between teams was the screen where every team looked alike. It was a shape problem rather than a drawing one: the list handed the dialog a name and an id and nothing to draw with, while the component that draws a team was already sitting there. It carries the face now, and a team with no uploaded picture falls back to its initials on its gradient, so none of them render as nothing.

Getting the server into a client meant reading the URL off the page and then knowing your own client well enough to finish the job: which config file, which key, whether it takes a remote URL at all or needs the mcp-remote bridge. Four clients, four different answers, and the page could only print all four and hope you picked yours. The endpoint now has an Open in beside it — the same button you already use to hand a card to an agent, prefilled with the app you last handed one to, because which agent you work in is a habit rather than something about the page you are on. What it hands over is that app's own install rather than a shared paragraph: Claude Code gets the one claude mcp add line, Codex gets the [mcp_servers.hardlysimple] block for its config.toml, Claude gets the connector steps with the desktop config as the fallback under them, and ChatGPT — which adds connectors from its own cloud, where no local command can help — is asked to walk you through the UI instead. Every one of them says access starts read-only, so the consent screen stays yours to narrow. The brief lands on your clipboard as well, so a machine with no protocol handler registered still gets the instruction, and each one is written to fit inside a deep link rather than trusting the OS not to cut it off mid-command.

On a phone the page around a deck took more room than the deck. The six tool buttons sat on the same line as the title and never gave way, so the title got whatever was left — on a 390-pixel phone that was about a hundred pixels, enough to render a Polish title as three letters and an ellipsis, with the kind label wrapped onto two lines and the facts under it in a ragged column. The label and the tools now share the top line and everything you have to read gets the full width underneath; the title runs to two lines rather than truncating, and the buttons wrap onto a row of their own where they do not fit. The deck frame has one floor now, and it is taller than the one phones had — seventeen cards in the reported deck used to overflow and grow their own scrollbars. Measured on that phone: the header lost seventy pixels and the deck gained a hundred.

A deck was the only thing here with nothing to look at. A sketch shows its scene and a chart shows its picture; a deck showed a grey rectangle with a slide count under it — including on a call stage, in the tile next to a shared sketch that was showing a drawing. The cover is drawn rather than photographed: the first slide is redrawn small, on the team's ground and in the team's type, with no browser started and nobody's scripts run to make it. It wears the deck's own light or dark, and it changes when the design system does. It shows in the three places a deck is a card rather than a page — the call stage, the databank item and the deck index. No logo is drawn on it, deliberately: an uploaded one could never load there, and a mark that appears only for the teams that never chose one is worse than none.

The showcase we point strangers at predated decks entirely: its last two steps asked your agent to write two self-contained web pages and upload them as files, which demonstrated a file upload on a platform that has a deck system. Every bowl now ends in five decks instead — a presentation, a card deck with backs, a print sheet, a long scroll and a decision deck. It is the same research measured against a screen, a sheet of A4 and a page you scroll, which is a difference you feel in ninety seconds and cannot get from a paragraph explaining it. The recipe reads the house style before it writes anything, so a bowl's decks follow the team rather than inventing their own colours. The link that hands the brief to your agent is built to fit its budget now, too, instead of being quietly cut off mid-word.

A team's decks could already take the team's colours and type, because those are captured from a repository — but not its logo. The mark on a title slide could only ever be a shape worked out from two colours, and that shape was ours. A team declares its own now: a logo for light and for dark, a wordmark, a slogan, how much the slides move and whether they carry page numbers, all set on the team's design page rather than captured from anywhere. Nothing already written is restyled, and a team that has declared nothing renders exactly as it did before. The first and last slides also stop being described and start being handed over, so three authors no longer build three different title slides. A logo is served without an account behind it, because a deck opened from a share link has none.

A deck built for a board listed nothing it was connected to. Its own page said “nothing connected yet” about a document whose entire subject was a taskboard, written by a named agent, on a run you could have gone and read — the row knew all of it and no surface ever asked. A deck is now part of the board it is about and a board contains its decks, in both directions; the run that wrote it is on both sides too, so you can go from a deck to the conversation that produced it and back again. The agent gets named properly rather than living in a twenty-pixel face with a tooltip: which of your agents it was, its lane, model and effort, how many turns it took and what it did, with the two ways in beside it. A run you are not allowed to open is left out rather than named and locked.

A deck that asks what a board needs decided was being handed every card the board had, finished ones included, and titled after the lot: sixteen live cards became a deck called “67 cards”, most of it work nobody was waiting on. It was worse than a miscount. A board hides its stale finished cards and reports them as a bare number, so an agent reading “6 cards, 75 hidden” concludes most of the board is missing and goes and fetches it. The count is split now, and the brief says out loud which cards it is about: the ones still in play, plus a note of how many finished ones it is deliberately not about. Freshness stops offering to rewrite a page because a card appeared and was finished in the meantime — though a card the deck already asks about moving to done still counts as drift worth knowing.

Reported on a sketch, and true of a deck's history for the same reason: the list of restore points did not fit sideways in the panel holding it. A row naming two contributors beside a full line of detail could never shrink, so the truncation those rows promised had nothing to shrink against — every Restore button was cut down to “Res”, and the list grew a horizontal scrollbar underneath it. Rows now give where the text is and hold their size where the thumbnail and the button are, and the box can no longer slide sideways instead of letting them. Measured against a sketch with five restore points and two names on them: rows that were forty pixels wider than their panel now sit inside it, with the Restore button a comfortable thirteen pixels clear of the edge.

A presentation is one side of a card, and a lot of what people wanted to show has two: a word and its translation, a question and its answer, a headline and the detail behind it, the same slide in the other colour. The flip deck is that — paged like a presentation, and every card turns over. Tap the card, press ↑ or ↓, or use the Flip button beside the pager; paging always lands on the front, because the back is the same card and not the next one. Ask a companion for one and it writes both sides of every card, and the deck says how many backs it got against how many cards, so a card that will not turn is caught before somebody reaches for it. On a call the presenter's flip turns the room's card too; anyone else's is a peek. The review page shows both faces of every card one under the other, labelled, and a word on either side can be fixed in place. A face can wear the other palette with one attribute, which is what a light back on a dark card takes. Hand-made ones paste in from the New-deck dialog like any other deck.

A shared sketch on a call is a thing a room is looking at, and until now the only way to point at part of it was a cursor. A cursor is one point, and “this bit, and this bit, and the shape between them” is not sayable with one. There is a highlighter beside the lock now: arm it, hold and drag, and the line stays for ten seconds and then fades over five. Nothing is stored — no element is created, the scene never moves, and fifteen seconds later there is no evidence it happened, which is the property that makes drawing on a canvas other people are working in safe to offer at all. It is a toggle, and only on a locked canvas, because on an unlocked one the pen is already right there and the drag belongs to it. A stroke lands on the same content for everyone, at any zoom, and stays on it while they pan underneath.

A shared canvas could already send you to somebody — click their face and their camera becomes yours — but not the other way round. On a canvas the size of a wall, “over here” is most of what a person says while drawing, and there was no way to say it. A bell sits beside the faces in the header now, which is both where those faces already are and the other direction of the same gesture: the faces take you to someone, the bell asks everyone to come to you. What arrives is a message with one button, and taking it puts you on the same region the asker is on, fitted to your own window whatever size it is. It does not start following them, because going where someone pointed and handing them your camera are different things to agree to. The bell is not there when you are alone.

The call has had a grid that holds the faces, the shared screens, the deck and the canvas together, each cell a way into looking at one of them properly. It was reachable only from the command menu, which is to say only by people who already knew it was there — from a stage, nothing on screen said “show me everything”. The filmstrip now ends in a tile that does: the same box as its neighbours, dashed until you reach it. And every cell in that grid answers now. A face, a deck and a canvas could all be clicked into focus while a shared screen quietly did nothing, and a grid where most cells respond and one does not teaches people the whole grid is decoration. Asking for the grid also holds: the next time a presenter swaps windows you are not yanked back off it.

The last control on a shared deck's row was “Original” — the author's page with our runtime taken off. That answers a question somebody reading the document has, and it answers nobody's while a room is being walked through the slides. What you want from that row mid-sentence is the deck's own page: to read it properly, scroll back through it, and still have it after the call ends. On a team call the row leads there instead. It replaces the escape hatch rather than sitting beside it, because a row offering both would be asking you to tell them apart while somebody is talking. A meeting room is the exception, deliberately: half that room may have no account here, and the plain document is the only thing a guest can open.

An agent's rewrite was the only copy of a deck there was: one write over the top and whatever had been there was gone. The document is now kept as it stood before every change to it — yours, an agent's, or a restore — so there is a list of the states a deck has been through, with who caused each one, and any of them can be put back. Restoring is itself a change, so the version it displaces is kept too and every restore can be undone from the same list. Anyone who can see a deck reads the list; only somebody who may edit it sees Restore. A run of small hand corrections in one sitting leaves one restore point rather than fifteen, an agent's writes each leave their own, and renaming a deck leaves none, because nothing in the document moved.

Two lines of feedback from somebody a deck had been built for: they wanted to fix small things themselves, quickly, rather than through an agent. Editing offered the whole document in a text box, which is not a way to correct a name. The review view's picker has a second setting now — turn on Edit text, click a line, and it becomes editable where it sits on the slide. Enter commits it, Escape throws it away, and on a touchscreen there is a Done button. Only that line changes: every other byte is left exactly as its author wrote it, so a one-word correction reads as a one-word correction in the history rather than as a rewrite of the page. A slide that has moved on since you started is refused rather than patched blindly, and so is an edit trying to bring markup in with it.

The card's Auto-agent panel shaped everything about the agent that would pick the card up — what it clones, what recipe it follows, which model it runs on — without ever saying which agent. Both its doors handed the card to whoever was watching, and the model and effort fields are Claude's vocabulary besides, so a team's DeepSeek or Cline agent had no handle on the card at all. There is a picker now, in the spot that was asked for: the agents that may take a card on this board, each labelled with the lane it runs in and, when it is not yours, whose it is. Picking one hands the card over, switching swaps it, and clearing puts the card back to whoever is watching. The collapsed line reads “handed to” and names them, so you can see it without opening the panel.

The board has known who is on a card for a while — a ringed face beside the title, the same faces down in the bottom bar — but none of it said so. A ringed face reads as “somebody is looking at this” until you hover it, the bar's faces had no caption at all, and the only words anywhere were a muted “2 running” in a collapsed panel, which on a phone sits below the description, the subtasks and every comment. The card wears a chip that says “Agent working” before anything else in its row now, the open card gets a banner naming each run with a link into it, and the faces in the bottom bar get a caption beside them. The face still says who; the words say what. A run that has just ended takes its banner down rather than waiting for you to close and reopen the card.

Reported from the booking page: a team called “Niewinni Czarodzieje Apartamenty” wrapped onto three lines inside a control twenty-eight pixels tall and spilled out above and below it. The box was a fixed width and the name inside it had nothing to be clipped against, so it simply grew. The control sizes to the name you picked now — “Just me” gets a small one, a team gets its whole name when it fits, and a longer one is cut with an ellipsis at a sensible cap. The one-line promise every dropdown in the app already made now actually holds, so this cannot happen again in the next one somebody puts a long name into. Measured with that team name: one line, twenty-eight pixels tall, and a seventy-character name stops at the cap.

The leaderboard's pick was made against three job shapes while the page beside it ranked three hundred and fifty models, and the two most expensive things this place asks of a model — writing a whole deck, reviewing a diff — were not among them. There are eleven now, in four groups, and their sizes are measured off what is actually stored here rather than rounded: the five deck kinds, the two surfaces a deck can belong to, a card errand, repository work, a code review sized on this week's commits, a workflow run sized on the longest recipe saved. Measuring them turned up a real hole. The pick only ever looked at how much a model can read and never at how much it can write in one answer — and a model that runs out mid-page returns a deck that stops halfway and reads as finished. It says so now, in its own words.

Sharing your cursor over a deck meant taking on faith that the dot everyone else was watching was where you thought it was: you saw your own mouse and nothing more. The slide draws your pointer for you now, with the same dot and the same name chip the room gets, so what you are looking at is what is being shared. It is drawn without the easing a remote cursor gets, because a smoothed local dot trails the hand moving it and reads as the app lagging rather than as a smoothed peer. The other half: a slide a room is looking at is no longer selectable text. A drag across it should be a stroke, not a sweep of highlighted words, and a stray blue selection over a shared slide is noise nobody chose. Text on the stage cannot be copied as a result — the deck's own page is one click away in the row, and it is untouched.

Reported from a two-person call: the pointer and the ink arrived in the right place and were still under the wrong words. Both halves were doing their job, and the mark landed within two pixels of where it was aimed. What moved was the slide underneath it. A house-style slide sizes its type against a sixteen-by-nine box, so a wide stage and a tall one lay the same slide out differently — on the two windows in the report the title was thirty-four pixels on one and forty-seven on the other, and a faithful point landed on a different word. A deck on a call is shown at its declared shape now, centred, with the rest of the stage left dark. Off a call it stays fluid, because a deck read on its own page should use the room it is given and nobody is comparing notes.

Everything filed in a databank that happened to be a deck read as the same word: Deck. A presentation, a print handout, the attention deck built for you overnight and a board's own deck were four different things wearing one label, and there was no way to ask for one of them. What a deck is turns out to be two questions — what it is, and which surface owns it — and the sheet narrows on both at once now, with a count beside each. Ask for decision decks in a workspace that has none and the chip saying so stays on screen, because a filter you cannot see is a filter you cannot clear. The sheet also counts the decks it cannot show you, the ones filed in no container at all, and links to where they live.

Two complaints about the same corner. The heart beside the wordmark sat a few pixels above it, and the little team face hanging off the lockup floated clear of the coloured rule it was supposed to be wearing — each one out of place because it had been positioned against the other rather than against the line at the foot of the header. The badge is anchored to that rule now: its middle sits on it, and the rule runs into one side and out of the other. With nothing left to make room for, the heart settles level with the wordmark and stops jumping when you switch between your own workspace and a team's. On a wide screen the badge used to be sheared off flat where a team's chat pane painted over the header; at 2560 pixels it is a whole face again.

An agent picking up a card connects to your workspace and is handed every tool it could conceivably need — about a hundred and ninety of them, some seventy-seven thousand tokens of descriptions read before it has looked at the card. An agent that only ever works cards has no use for the calendar, the sketch canvas or the deck contracts. You can now name the catalogue an agent connects to, and its pickups carry that one instead: naming the tasks catalogue cuts what it reads by more than half. It is something you choose rather than a default, deliberately, because a pickup's instructions are free text and the same agent may be asked for a deck one morning and a pull request the next. Name a catalogue that does not exist and the run still gets the full set rather than dying at the door.

A cursor is a point, and most of what a person says over a deck is a shape: circling three rows of a table, underlining a total. Hold the button and drag, and the line appears on everybody's slide while you are still drawing it, holds for ten seconds, then fades away over ten more. Nothing is kept. The deck's own bytes are untouched, no annotation is attached to it, and twenty seconds later there is no evidence it happened — which is the property that makes drawing on somebody else's document, in front of a room, a safe thing to offer at all. The line lands on the same content for a viewer whose window is half the size of yours, and it is redrawn in the right place if they resize. A click that does not travel leaves no dot, so the links on a slide are still links.

In a list mixing files, images, sketches and decks, every deck drew the same picture — the presentation glyph — so a decision deck, a print handout and a web page were indistinguishable until you opened one. Decks now wear a shared base with their own kind's mark badged onto it in the accent colour, in the content sheet, in the list view, and on a card whose preview will not load. The shared base is the point: it keeps decks reading as one family in a mixed list, which five unrelated glyphs did not. The colour is load-bearing rather than decorative — at the fourteen pixels these rows actually use, a monochrome version merges into an illegible blob and every kind looks the same again. Where every row on screen is already a deck, the plain mark stays.

A deck put on a call stage was served through an older door than the one behind its own page, and that door left two things out. Your team's deck styling never reached it, so a deck built to the house look rendered plain in front of the room while looking correct everywhere else. And any image the deck pulled from a databank was refused inside the call's frame, so a slide that was fine on its own page arrived with holes in it. Both surfaces that put a deck in front of people — a team call, and a meeting room where half the audience may be on a guest link — now hand out the same document the deck's own page does. The rule underneath it is worth saying once: what a deck can do is decided by the door it was served through.

Paging a room to slide seven says which slide is being talked about and nothing at all about which bar of the chart on it, and this one here is most of what a person says over a deck. The presenter's cursor now travels with the slide, on both surfaces that put a deck in front of a room. What goes on the wire is not a position on your screen: every viewer's deck is a different size, so the point is sent as a fraction of the slide itself and lands on the same word in a window half as wide. Only the presenter's cursor is ever drawn, someone who has paged ahead is not shown a pointer aimed at a slide they left, and a cursor that stops arriving disappears rather than freezing on everyone's slide. You are told your cursor is shared, and moving off the slide is the off switch.

A model that answers with provider errors sat on a live team's agent and failed thirteen runs in a row, and every step of diagnosing it was done against that team's real configuration — because a team may have exactly one agent of each kind, and there was nothing else to test with. Throwaway agents can now be conjured beside the real one instead of replacing it: several at once, each on a different model, so the same card can be run through them and the answers compared. They never appear as a team's own lane, and deleting one revokes the credential it was given in the same motion. Only the agents the deployment itself runs can be made this way. An agent that runs on somebody's personal account would spend their subscription, which was never an administrator's to spend.

A team can see its own agents and what they have cost. Nobody could see all of them at once, and a model going quiet is a fleet-shaped fact: the same free model backs agents on several teams, so when it stops working they stop together. Answering what is everything running, and which of it is broken, took a shell on the server and queries written by hand. There is a page for it now, one row per agent across every team, built from the same loader and the same parts as the per-team page so the two can never disagree about whether an agent is healthy — the only difference is one join. It covers the agents the deployment runs, and it opens only for people who administer the whole deployment: a team manager's reach stops at their own team, which is exactly what this page crosses.

Cutting what a connection is shown to what its permissions allow does nothing for a connection allowed everything, so a full-access agent still received every tool before reading a word. There are named doors now — tasks, decks, sketches, knowledge, repo — and connecting through one publishes that area's tools alone, cut again with whatever your grant already allowed. A door can hide a tool your grant allows; it can never reveal one it does not. Measured on a full grant, the tasks door serves eighty tools where the front door serves a hundred and ninety, and a read-only token on it serves thirty-seven. Ask for a door that does not exist and you get an error naming the real ones, rather than the whole catalogue served quietly. Four tools that restated a long contract their twin already spells out now point at it instead.

A deck whose slides sit inside one wrapping element arrived as a single slide with a pager that did nothing, while the count stored beside it said three. The page that serves a deck adds a few things of its own after the author's markup — the team's styling, the runtime that pages it — and the part that goes looking for slides was counting those as content, giving up, and treating the whole document as one long page. Nothing that cannot render is treated as slide content now, whoever added it, which also covers an author's own trailing block of styling that broke it in exactly the same way. Decks written the ordinary way are untouched; the ones that were wrong go from one slide to three, the number the deck always said it had.

A deck built on a fixed canvas has to be scaled down to fit whatever window it is read in, and the scaling was anchored to the middle of the slide rather than the middle of the frame. The narrower the frame, the further right the result drifted: in one common size the slide sat eighteen pixels off the right edge, and in a smaller one all but a sliver of it was outside the window entirely, with nowhere to scroll to reach it. It is centred properly now, including when the deck's own layout indents the slide before anything is scaled, and it stays put across repeated resizes rather than walking a little further each time. Decks written in the house style size themselves to the window and never took this path at all.

A sketch several people are drawing on is written to the server by one of them, on everybody's behalf. Everyone else's pill said Saved the moment they drew a stroke, which was a guess and sometimes a wrong one: strokes made while a save was already in flight could be filed as stored when the server never had them, and reopening the sketch would then quietly drop them. A save now comes back with proof of what it contained, and your pill settles only when that proof covers what is on your canvas. If nothing comes back within a few seconds you are told the work is unsaved, rather than shown a spinner aimed at a tab that has since closed. Joining a sketch mid-session also pushes you what the room has already drawn, so a newcomer cannot save over strokes it never heard about.

Reported from a call: a sketch shared onto the stage stopped saving for the people drawing on it. One person in the room writes to the server for everyone, and the room is larger than it looks — everybody with the sketch on the call, plus anyone who left a tab open on it days ago, plus you, twice. The job went to whoever had joined with the smallest identifier, which was routinely a background tab. A browser slows a hidden tab down to one tick a second, then one a minute, and eventually freezes it outright, so the saving ran far too slowly to be saving, or not at all — and a frozen tab looks perfectly healthy from the server's side. The job now goes to somebody with the canvas in front of them, and if that one goes quiet the room hands the pen on without anyone having to coordinate it.

Every restore point in a shared sketch was stamped with one name, whoever happened to be doing the writing, so the history of a drawing three people made read as one person's afternoon. Worse: once anybody's snapshot existed, nobody else's editing produced a restore point for five minutes, and in a live session each new capture pushed that window out again, so it stayed one person's for as long as the room lasted. A restore point now records everyone whose strokes it carries, with their faces in the history list, and a fresh one is cut the moment somebody not yet credited on it starts drawing. Someone idly relaying other people's strokes is not credited for them, and every name claimed is checked against who can actually see the sketch before it is written down.

A connection granted nothing but read access to tasks was still shown the whole catalogue, every destructive write included, and found out it could not use them only by trying. The listing ignored the permissions the calls themselves have always enforced. What a connection is shown is now cut to what its grant can reach: read-only sees a third of the catalogue, and a token that can only read tasks sees sixteen tools out of a hundred and ninety. This is not tidiness — the catalogue is the largest fixed cost anything connecting here pays, tens of thousands of tokens read before the first question is asked. Hidden rather than absent also fails honestly: ask for a tool outside your grant and you are told it is turned off, not that no such thing exists.

Filing a sketch, a task, a deck or a presentation into a databank meant eleven near-identical tools whose only real difference was the name of the identifier they took — a meaningful slice of every catalogue spent on the word for one thing. They collapse into a single call that takes what you are filing and what kind of thing it is. The permission each one required is unchanged and still checked at the moment of use, so filing a sketch still needs permission to read sketches and the shorter list opens no door the long one kept shut. The eleven old names go on working for one more release and say plainly that they are on the way out, so nothing built against them breaks on the day the short one arrives.

The catalogue every model is ranked from carries the model's own claim that it can call tools, and the suggested pick trusted it. The model it suggested for a free card errand was the one this deployment already knew was broken: named in its own notes as returning provider errors, thirteen failed runs the night before, advertised as tool-capable throughout. A model that has actually been watched attempting a tool call now outranks that claim — one measured working is preferred over one that merely scores higher, and one measured failing is refused outright. Only ten models out of hundreds have been measured, so an unmeasured one is left exactly where it was rather than punished for the gap. The winning row says which of the two it had, because we watched this work and the catalogue says so were rendering identically.

The fleet page marks a model fragile when a single provider serves it, because that provider's bad minute is the model being down. It was saying the exact opposite about the one model chosen for its redundancy. A router has no providers of its own — it picks from the pool on every call — so it reported none, was swept in beside the single-provider models, and was labelled as served by a single provider while being served directly by none of them. Having no providers is now a third answer with a reading of its own, rather than an extreme case of having few, and the badge and the sentence explaining it are drawn from one place, so the next thing that reads it cannot put the boundary somewhere else.

The road a model takes is worked out from the shape of its name, and exactly one name defeats that: the free router, where the word free is part of the model's name rather than the marker the test looks for. Since that router became the default, every team's agent picker had shown it with a paid pill and a note explaining billing for something that costs nothing. It gets a road of its own now rather than being folded in with the free ones, because the difference is the reason it is the default: it is the only road at no cost with anywhere to fall when a provider refuses, and the price of that is not knowing in advance which model answered. The paid router keeps its pill, and a test now pins the promise that a fresh deployment costs nothing to run.

The page listing a team's agents said no runs and nothing spent about an agent that had built the team's board deck the night before, and about another that had just finished an errand successfully, while the agent beside them counted its runs perfectly well. The counter only knew about work that started from a card. An errand with no card behind it — a board deck, an attention deck — was invisible to a page whose whole heading is what an agent's runs have actually cost. Both kinds are counted now, and a run appearing in both is counted once rather than twice. The zero beside the money is unchanged and still honest: one lane reports nothing about what it spends, which the page says out loud. What is different is that nothing spent over three runs now reads as unmeasured instead of as never ran.

A DeepSeek or Cline agent handed a card that links a repository got a scratch directory with nothing in it, and a brief telling it the code was already cloned, to commit, push and open a pull request. None of that was true, so a run that did everything it could still read as a failure. Those agents get the checkout for real now: the repository the card links, on a branch made for that run, in the place the brief names, prepared the way it has always been for a Claude run. The credential that reaches the clone is sealed for the length of one call and never travels in the open. And when a clone cannot happen at all, the brief says so in as many words and asks for the platform half of the work instead of a pull request that was never possible.

Answering what your agent is running, whether that model is healthy and what it has cost took a shell on the server and three queries, and a team that owns an agent could answer none of it. There is a page for it now, one row per agent, with the model it runs, the published price, what its runs actually reported spending, and how old the reading is. The signal worth the page is how many providers serve a model: a free one usually has exactly one and there is no failover, so that provider's bad minute is the model being down, which is how a live run died at its fifth step saying only that a provider returned an error. Single-provider models are marked fragile before they fail. And because serving is not the same as working, a model can be probed for whether it can call a tool and fill the arguments in, with every attempt kept.

A pinned default has nowhere to fall, and on the last day of August it fell: one donated provider started refusing and every agent carrying the same free model stopped at the same moment. The leaderboard now shows a pick made from live facts instead. Three real job shapes are sized against what they cost before the first message is even sent, because being an agent here reads about seventy-eight thousand tokens of tool descriptions to begin with, so a small window is not a cheaper version of a big one but a model that cannot build a board deck at all. Anything that cannot call a tool, cannot see an image the job needs, or has an announced withdrawal already past is ruled out. What comes back is a shortlist, never a single name, and each lane shows its winner, its fallbacks, and how many were ruled out and why.

The free lane's default was one model served by one donated provider, so when that provider throttled, every agent inheriting the default failed together and none of them could fall anywhere. Measured at the time: a single-token request came back rate-limited upstream, the same request asking for a long answer came back a gateway error, and a router over the whole free pool served the identical call through somebody else without complaint. The default is that router now, on both harness lanes. Free is still what you get without choosing; it is no longer a single point of failure. The harness's own way of reporting that failure was to blame your wallet, which sent an evening into three funded accounts before anyone thought to probe the model, so a refusal that names your balance now carries a line telling you to check the model first.

Pressing build on a board deck puts a line on the board so the wait does not look like nothing happening. A build that died put the board back exactly as it was: the line gone, the button armed again, the board reading no deck yet. Thirteen failures across twenty minutes, and the board never said one of them out loud, so the only visible outcome of asking was being invited to ask again. A recently failed errand is shown now, dated from when it failed rather than when you asked, so a build that retried for the whole window still reports. Failures stay out of the count of live work, so the button and the agent picker behave as they did. And an agent told to read a board's existing decks before building another can finally list them, which was the first thing it tried and the first thing it was refused.

Two agents claimed a card within a tenth of a second of each other and the second waited out the first's full two minutes, because harness runs share one execution slot while the limit that holds them back is counted per agent. Nothing said so. A queued run looks exactly like a working one, a session that has started with an empty transcript, and the console wrote Thinking over it, which was a false statement about a run that nothing was executing. A run waiting its turn now says it is waiting, how many runs are ahead of it, and that harness runs go one at a time. Thinking is suppressed rather than layered on top. A run that is second in line never reports nothing ahead of it, because under-reporting the wait would read as the same stall all over again.

Switching on a team agent with the obvious watch tag claimed a substantial human planning card within one tick, because that card's tags were topic labels, the name of a provider and the word research, and nobody meant them as an instruction to go and work it. Only a missing binary stopped the agent from starting. Tags are how you label a subject and how an agent is told what to take, and those two jobs want opposite things. Choosing one now tells you how many cards it would claim right now, counted with the picker's own rule rather than an approximation of it: visible to the agent's owner, not archived, not blocked, not already claimed, not sitting in a board's last column. A number worked out some looser way would name a figure nobody could reconcile with what happened, which is worse than no number.

An agent's model was a list of raw identifiers in which some options simply could not work, and the refusal you eventually got said the model may not exist or you may not have access to it. The first half is untrue and the second is the whole story, so the natural reading pointed at a typo when the problem was entitlement. Each option now says which road it takes. A free one costs nothing but is capped for the whole account rather than per model, and one pickup is many requests. A paid one is unreachable on a key with no credit. A bare name goes straight to the provider on its own key instead of through the gateway. None of that is a second hand-written list to keep in step with a catalogue that changes weekly: the labels come from how the names are resolved, so the wording and the routing cannot disagree.

When nothing is there to execute a harness run, the platform holds the card rather than claiming it, which is honest and looks identical to nobody watching that tag and to the agent simply being busy. The only account of it lived in a log line on a server most people cannot open. Your agent's own panel says it now, on the team page and on the agents tab, phrased as availability rather than as infrastructure: temporarily unavailable, and who can put it right. It is a line, not an alarm, because it corrects itself within a tick of capacity returning and must not read as though something was lost. And when we cannot tell, because the thing holding that answer is itself unreachable, it says nothing at all rather than announcing an outage we merely failed to check for.

What a team's DeepSeek or Cline agent had cost had no answer anywhere, and it matters more for those lanes than for a Claude one: a Claude run spends the subscription of whoever owns it, while these spend a key somebody pays for centrally. The figures were already being reported at the end of every run and carried back, then written into a log and dropped. They land on the row the team panel already adds up, so a panel that had been counting every harness run as nothing now shows what they really cost, with no second ledger and nothing counted twice. Unmeasured is kept apart from nothing: one of the two lanes reports no usage at all, so a run that measured nothing leaves the figure untouched instead of asserting a zero, and a reader can still tell which is which.

The deck picker on a board offered every agent you had ever configured. On one team's board that was thirteen entries, three of them identically named, only one able to see the board at all and nothing on screen to tell them apart, and picking a wrong one sent the errand somewhere it could not go. Two halves of one rule were at fault and each hid the other: an agent you own arrived at the browser with its team stripped off alongside its labels, and the check deciding whether an agent may take an errand waved through anything you owned, which is every team agent, since whoever pressed save first owns it. The rule turns on the team an agent belongs to now. A team's agent works that team's boards, and ownership decides only who may point it. An agent bound to no team stays private and goes wherever you can.

Moving a card between columns on a filtered board failed every time with the taskboard changed, reload and try again, and the advice could not work: reloading re-applies the same filter, so the next drop fails identically, forever. It was reported from a phone with the mine filter on, and it was true of every filter. The board hands the drag what it draws, so a drop reports the neighbours you can see, while the check that accepts it demands the two cards be genuinely next to each other in the whole column. Hide one card between them and they are not. A drop now keeps the card you aimed at and quietly swaps its hidden partner for the real neighbour on that side, so the card lands where you put it: on a five-card column with one hidden, exactly between the two you dropped it between.

A harness run that failed released its card and left nothing behind. The card looked untouched, so a team saw an agent that was switched on, correctly tagged and silently doing nothing, and the only way to learn why was a shell on the server. The card carries the failure now, in one of three voices, because flattening them would cry wolf on the two that fix themselves: a run cut short by a deploy or one that went stale is a quiet status line, a provider having a bad minute is a quiet status line, and anything else raises a flag, since that one repeats until somebody changes something. The reason is quoted rather than paraphrased, and it is a real reason now, naming the provider that refused and what it said, instead of one sentence that a rate limit, a withdrawn free route and a gateway fault all produced alike.

When a run is refused for hitting a usage window, everything worth knowing was already recorded and none of it was shown: which window is spent, when it lifts, and how much of the longer one is left. What you saw instead was the next line, saying the selected model may not exist or you may not have access to it, with an instruction to pick a different one. Not a clause of that described the situation, and the question being asked at the time was whether a limit had been hit, which the row directly above had answered. A refusal now names the window that stopped it and the time it resets, and reports the longer window beside it, because five hours spent with the week barely touched means waiting really is the whole fix. It says refused rather than nearly full, because only one of those is true.

One agent, one configuration, four runs and three different answers to what model this is, one of them naming a provider the agent had never been pointed at. The routing was right the whole time: a run that reported its own cost priced itself at about a penny and a half, which is the cheap model it was genuinely using and dozens of times under what the name it printed would have cost. Only the label was wrong, and the label is the whole of what anyone sees. It sits on every comment the agent writes, in the console, and in the record of what ran. The cause was taking the tool's own word for what it was running rather than what the platform dispatched it as, so the dispatch wins now, field by field, and the same agent stops introducing itself differently from one run to the next.

Two pieces of feedback about the same bottom bar. Most of its controls carry a word, Calendars and Booking link and New event, and two did not: the layout switch and the activity wash were bare glyphs whose only explanation was the label your operating system shows after a second, which nobody waits for. Changing the colours turned out to be the thing she found by pressing it. Those two say their name now on a wide screen, and every control in the row explains itself quickly on hover at any width. The booking link had also been hidden on a team's calendar, on the reasoning that a booking page belongs to one person, which is a reason to say whose it is rather than a reason to vanish, especially as a booking link can be shared as part of a team. It shows on both now, pointing at your own page and saying so.

Two different agents were given the same brief for building a deck, with the house style spelled out in it, and each broke a different rule the brief had stated. When two of them miss the same thing independently, the brief is not what needs fixing. A deck can no longer be accepted with a hand-written copy of the house style pasted inside it. One of them had redefined the whole vocabulary inline, the colours and the type and the animation, and because the values happened to match, it renders perfectly today and freezes the moment the standard moves, with nothing anywhere to flag it. Three ways of using the real standard are sanctioned and two of them are inline, so the check looks for the marks all three carry rather than demanding a link and rejecting the very thing the tool offers you first.

Columns side by side answer where a card stands, and the list view answers where the card about X is. Neither answers the question a board with more than four columns makes hard, which is what is in all of them right now: a laptop fits two or three columns at a time, and the list dissolves the columns into a sortable field. Lanes is the same board turned on its side. One full-width row per column, its cards running left to right inside it, drawn as the same cards in the same board style, so six columns fit on a screen where three did. The trade is depth, and it is deliberate: a lane's cards are capped and clipped with a fade marking the cut, because one tall card would otherwise set the height of the whole row and push every column below it off the screen. Dragging within a lane, across lanes, and reordering the lanes themselves all work as they always did.

A booking's page, a deck's share URL, a meeting link and a team invite were four separate secrets with four separate lifetimes, and the cancel link mailed out with a booking never expired at all, so anyone who kept that email could still call the meeting off a year later. They now resolve through one door: one lookup, one rate limit, one identical refusal for every kind of failure, and an expiry on every link, because temporary is the point rather than an option. A link that carries its own grant opens in place; the rest verify and forward you on. You can revoke one, and see how many times it has been opened. Links already in the wild keep working, since the old addresses now redirect to their twin behind the new door and revoking acts on both at once, and a booking link that has merely lapsed says the booking is past instead of pretending it never existed.

A deck that pointed a picture at the exact databank address the platform hands you rendered a broken image every time, on its own page and on a shared link alike. Nothing was misconfigured. A deck is served sandboxed, so it runs in an opaque origin, an opaque origin sends no session with its requests, and the route that serves stored files answered a request with no session by bouncing it to the sign-in page, so the reader got a page of markup where a picture should have been. Two rules that were each right had never been read together. The route that serves the deck now checks each picture the way it would if you had opened that file directly, signs a short-lived pass for exactly that one item, and the gate lets that single shape of request through. Sharing a deck publishes its slides, not a reader's whole databank: a guest with no account sees only what the deck's own audience could already open.

Handing the job of building a deck to an agent only ever worked for a Claude one. Pick your team's DeepSeek or Cline agent and the errand went down the Claude road regardless, arriving as a session stamped with a model that account had never heard of, and the run died claiming the model may not exist or you may not have access to it. Not one clause of that was true. Those agents now take the errand on their own harness. And because fabricating a deck takes minutes during which the board looked completely untouched, long enough that people pressed the button again and ended up with a second deck asking the same questions, the board's deck menu, the deck dialog and the attention page all name the agent that is building this while it works, with that agent greyed out in the picker until it finishes.

The agents section lived on the Claude settings page, and it spoke only Claude's vocabulary: it could not add a DeepSeek or Cline agent for your team, and it had no words for their models or their reasoning levels. Agents get a tab of their own now. Your personal Claude profile sits at the top, and beneath it, for each team entitled to one, the DeepSeek and Cline panels with their own model and reasoning pickers, where creating one is the same first save it always was on the team page. The Claude-only controls list Claude profiles only, because a harness agent edited in Claude's vocabulary came out corrupted, and a column cleanup dispatched on one launched Claude with a model id it could not use. The settings navigation also scrolls within itself on a phone rather than widening the page, which it had been doing since the seventh tab arrived.

Every DeepSeek session in the product showed the brief it was given, the words Turn complete, and nothing else. The work was not missing. A full written account of the run was sitting in the row directly underneath, in a payload the console treats as a one-line footer and never prints, which is right for a lane whose closing message arrives on its own and wrong for this one, which streams nothing at all and so keeps its only account of the work in that footer. That text is now promoted to a message of its own, and a DeepSeek transcript reads like any other: what it did, then how it ended. The minutes in between are visible too, because the run's own session log is followed while it works, so its messages and its tool calls arrive as they happen instead of landing in one lump at the point where they stop being progress.

A DeepSeek agent shipped with web search mounted into every run's toolset and no key behind it, which is the worst arrangement available: the tool was offered to the model on every card and failed with a credential error the moment anything reached for it. It has a key of its own now, and the search works. The same key opens DeepSeek's own route alongside the gateway, and the model id you pick chooses the road, so a plain id goes direct while the same id written with a provider prefix goes through the gateway exactly as before. Nothing new is installed to do any of it, since both routes were already in the image. A deployment holding no key passes none rather than an empty one, so a run that calls search fails loudly and legibly instead of authenticating with nothing and failing somewhere further in.

A DeepSeek pickup would open with the first step of its brief, read this card, and get back an error saying no such tool exists, then burn several calls guessing until it stumbled onto the right spelling. The brief was not wrong; it was written for a harness that resolves a bare tool name by itself, and this one does not. It types what it is given, verbatim, and its tools carry a longer qualified form of the same names. A kickoff is now spelled for the harness that will read it, so a DeepSeek run gets fully qualified names plus one line stating the rule for the tools the brief does not name itself, which covers a workflow's steps and an operator's standing instructions. Cline is deliberately left on bare names, because its registry cannot be read and a prefix invented for it could break a lane that takes bare names today.

Choosing a model for an agent meant reading a provider's own marketing page and hoping. The leaderboard reads the catalogues behind the keys the deployment actually holds and ranks what is in them, with free and paid as separate lanes. Free is decided by the price sheet rather than by the name, because the usual free-looking suffix is a convention: a model with no suffix can be free, and a per-image or per-request charge keeps one out of the free lane no matter what its tokens cost. Two orderings are offered, since top means two different things, and both come from the catalogue itself: a set of composite scores for intelligence, coding and agentic work, and the provider's own most-used lists, which is where the tokens really go. A model the active ordering cannot place sits in a collapsed section below the ranking, unmeasured rather than last.

The round button in the bottom-right corner searches everything when you tap it and records a memo when you hold it, and it was drawn as a lightning bolt, a quick-action metaphor that covered both jobs at the cost of naming either. Somebody filed exactly that as feedback: this should be a search icon. It is one now. The bolt had also quietly become a name, so the copy calling it the lightning button had to move with the icon or start lying, which took the help dialog, the memo starter's subtitle, and the feature tour, whose phone mock was drawing a bolt of its own. The mobile app's version of the button exists to mirror the web one, so it got the same swap rather than being left behind. Three words that had been glued together in the help dialog came unstuck on the way past.

The settings tab strip is wider than a phone and it always started at the first tab, so on a 390-pixel screen three of the eight tabs were visible, the one you were actually on was usually not among them, and nothing on screen suggested the row scrolled at all. The page read as broken rather than as cut off, and it got worse every time a tab was added. The strip now centres the active tab when the page opens and again whenever you move between tabs, with the partial tabs on either side doing the work of showing you there is more. It only does this when the row is genuinely too wide, so the sidebar on a larger screen is untouched. A session the platform opened on an agent's behalf now says model not declared as well, instead of leaving a blank where the reason should be.

Asking a board four questions used to mean authoring a whole document, because producing one was the only thing the deck interface accepted. That is a design exercise standing in front of a simple errand, and it carried a second cost: given the same four-question brief, the agent whose page looked best had inlined a fork of the entire house style rather than linking to it, so that deck renders correctly today and freezes the moment the house style moves. A deck may now arrive with no document at all, provided it declares its decisions, and the platform writes the page. Each decision can carry a couple of hundred characters of context, the two or three facts somebody needs in order to answer it without opening anything else first. The richer authored deck is unchanged and still there for when the presentation itself is the point.

A deck's decisions sit in a rail beside the slides, and that rail had a height and no scroller of its own, inside a page shell that is a fixed height and hides its overflow on a wide screen. So a rail taller than the window did not make the page taller. It spilled past the bottom edge and was clipped, with no scrollbar anywhere that could reach it. Measured on a four-decision deck at an ordinary laptop size: eleven hundred pixels of rail inside a seven-hundred-pixel column, a document exactly as tall as the window, and the third and fourth decisions unreachable by any means at all. A deck whose decisions cannot be answered is not a cosmetic problem. The rail scrolls itself now, on wide screens only, because stacked on a phone the page already scrolls and an inner scroller there would just trap your thumb.

Open the same work in two lanes and you got two different products. A Claude run showed tool cards, each with the tool it called, how it went and how long it took. A Cline run showed prose: alright, let me read the card first. The intent, never the act. Its tool calls had been streaming past the whole time, and the reader was simply looking for sentences, because text and tool calls ride the same two kinds of event on that stream and are told apart by one field nobody was reading. Every tool call a Cline run ever made was dropped on the floor. They are written through now in the shape the transcript already understands, which is why this costs nothing to display: the console pairs a call with its result and takes the duration from the two timestamps, exactly as it does for every other lane.

A deploy that shipped half of the agent runner produced the worst-shaped failure this system has had. The card read as claimed, the console showed a live session, and nothing anywhere was executing it, because work was being queued into a list with no reader. Nothing was permanently stuck, since the lost-run check does eventually write the session off and free the card, but the cost was sixteen minutes of what looks exactly like an agent thinking, then a release, then a wait, then the same again for as long as the card sat there. The answer is not another timeout, it is knowing whether anybody is home. A worker reports in on its own timer now, and the runner refuses to dispatch when none has. That refusal happens before any card is claimed, so a tagged card simply sits in its column reading not started, which is true.

A card handed to a team's train could be picked by the team's DeepSeek agent and then quietly worked by Claude on the card owner's own subscription, with the DeepSeek agent's name left on the card as though it had done the work. The pool that chooses an agent was reading one field that means two different things: on a personal Claude agent it records whether its owner ticked takes team work, and on a team's harness agent it records that the team owns the agent outright. So every harness agent sat in its own team's pool for free, and the train dispatched it down the only road it knew. The pool now takes Claude agents only, and fails closed, so a fourth kind of agent stays out until somebody teaches this path what to do with it. A team whose agents are all harness ones sees the honest hold it already had for that case.

A board played as a card game prints a mini playing card beside each task's title, and at twenty-two by thirty pixels the suit read as a smudge and the rank as a mark. The feedback said so in as many words: the card symbols should be bigger and more visible. The mini now sits at twenty-six by thirty-six, a real card's own proportions, with the rank and the pip grown to match, and its baked edge carries noticeably more ink so the cream face keeps a visible outline against a dark board. The smaller chip variant grew alongside it, so a row that mixes a designation with the shoe, the joker and a bust still lines up instead of stepping. The three faces share one frame now, rather than three hand-copied sets of styling that were free to drift apart.

Connecting Codex to this platform failed at the last step of the sign-in handshake with an invalid redirect address, and it was nobody's misconfiguration. That client registers its return address without a port, then listens on whichever port happens to be free and asks to be sent back there, while the authorization step was comparing the two as exact strings and refusing the difference. The standard for this case says the port is the one part of a local return address that must be ignored, and now it is: the scheme, host, path and query still have to match what was registered, a fragment is still refused outright, and only local addresses get the leniency at all. Every other client is unaffected, and the handshake still ends at the address the client actually asked for, so the step that exchanges it for a token lines up untouched.

A team agent picked up a card, worked it and left nothing behind that anybody could open: no row in the agent console, no link on the card, and every action it had ever taken through the platform merged into one endless “Untitled session”, because with no run to name it the only thing left to key on was the agent's single token. Each run now gets a session of its own. It is listed in the console with the model it used and how it ended, the card's pickup carries an Open run link, and the transcript holds both the kickoff and the result. A run that fails lands as an error with the reason on it — the first time a failure has been visible anywhere but the runner's log. The supervisor that rescues stalled sessions no longer adopts these either: it had been answering work a container had already finished with a fresh Claude turn, on somebody's own subscription.

An auto-agent has always belonged to a person: it rides your connected account, spends your subscription and sees what you can see. A team on the premium plan can now be granted one of its own — a DeepSeek harness that watches the team's tags, claims the cards that match and works them without anyone starting it. Two switches, deliberately held by different people: a platform admin grants the entitlement, then the team's owner or admin sets the watch tags, the model, the effort and the standing brief. It stays off by default even for an entitled team, because this one spends the deployment's shared key rather than anybody's own, so handing a team an autonomous agent is a decision rather than something that happens to you. One per team, and it borrows the reach of whoever configured it — named in the panel rather than left to be guessed at.

One agent working your cards tells you that it works; two tell you which is better at it. A premium team can now hold a Cline agent beside the DeepSeek one, granted and configured exactly the same way, watching tags on the same boards. The two entitlements are independent on purpose — a team holding both is the point, because that is the only way to put two harnesses on the same kind of card and read the difference. Everything around them is shared: one per team, its own sealed token so it can comment on and move the card it is given, the reach of whoever set it up, and the same model list, so what differs between two runs is the harness rather than the model. Each keeps its own effort scale. And a run that fails now benches its agent for one, then five, then fifteen minutes, instead of starting a fresh container every few seconds against a key that will never work.

Both team agents shipped pointing at a paid model, so a deployment whose key carried no credit failed on every single card — and the refusal read as though the model did not exist, which sends you hunting for a typo instead of a billing page. The default is now a free model, and the shortlist behind the picker is free-first. Every id on it was checked against the live provider rather than taken from a bundled list: each had to answer a realistic request by emitting a tool call with its arguments actually filled in, and several plausible candidates failed that and are simply not offered, because an agent that cannot call a tool cannot comment on the card it was handed. The effort picker changed with it. Where it read “Default (high)” it now reads Provider default, and an agent with no effort pinned sends none — the forced default was what made the free model refuse to start.

Narrowing a sketch, a databank, a knowledge bundle or a repository to a handful of people hid the thing itself and stopped short of the places that talk about it: the dashboard's around-me feed and the team page's activity still carried rows for work on objects you had been restricted out of, naming them on the way past. Those feeds now consult the same access lists the objects do, one kind at a time, so a restricted object's activity is invisible to everyone but the people named on it and whoever made it. The same goes for the team's list of companion sessions — an agent whose only trace on the team is work on a restricted bundle stays hidden along with the bundle — and for the chip that names a workspace in the audit view. Platform admins still see everything, and a table inherits whatever its workspace was told.

On a phone, a databank filtered down to two rows left its pager stranded mid-screen, half underneath the omnisearch button — reported, fairly, as paging turning up in a weird place. The bar had been pinned with a rule that can only pin something whose natural position is already below the fold; on a short page that position is the middle of the screen, so the middle is where it stayed. The landing's pager and the databank toolbar now hold the bottom edge outright on small screens, in the lane the omnisearch button leaves clear, and the list above buys back the height they cover so the last row never hides behind them. On a wide screen nothing changed: both bars still sit at the foot of a column that already holds them there.

Every other team object — a sketch, a databank, a knowledge bundle — could already be narrowed to a handful of people, and a taskboard could not: joining the team meant seeing every board in it, including the one about a reorganisation or somebody's offer. A “Who can see this board” row in the board's actions menu now takes a list of names, and the restriction follows the board everywhere rather than merely hiding it from the index — search, the dashboard, an assigned-cards view, the attention feed, the team's activity and an auto-agent's own pickup all inherit it, and a card's title stops arriving as a notification to somebody who cannot open it. Whoever made the board never loses it. Moving a board to another team lifts the restriction, which is the rule a sketch has always followed.

Whether anyone was talking to you lived in three places: a bell for pings, an inbox for calls, and a messenger you had to already have open. One icon now sits above the search button in the corner and answers it. The teams with something waiting orbit it as small faces wearing their unread counts, a live call outranks any pile of unread, and the whole thing rings with an emerald halo for as long as a call is joinable. Click it for a hub — switch teams, join a call the inbox knows about, or dock a conversation into the corner and keep reading the page you were already on. Picking a conversation swaps the panel for the thread in place, so the corner column reads search, then coms, then whatever you are typing in.

A board with no end in sight is a board nobody argues with. A card-game board deals every top-level card a playing card instead — Q♥, 7♦ — and runs against two clocks at once: fifty-two cards, and a fortnight per deck. A finished card keeps its card, so one deck is fifty-two tasks the board will ever hold rather than fifty-two open at once. Losing either way blocks nobody: the fifty-third card is still created, it simply has no designation left to wear, so it gets a dashed red BUST badge and the team hears about it once, as a decision somebody has to make about the card that lost the bet. Subtasks are never dealt — a subtask belongs to the card above it, and dealing them would burn the bet on checklist items. The four pip shapes carry the difference between designations, so colour is never the only thing telling two cards apart.

A deck lived behind a login, so showing one to an investor or a candidate meant a screen share or an export. A deck's page now has a Share button that mints a temporary public link, opening on the same front door a meeting link and a booking link already wear: the brand over it, the team's crest and your face across one card, a wash of your colours behind, and a pager and slide list under it. On a phone the deck takes the whole door rather than the 200-pixel strip it used to get with empty space above and below. It is a list of links rather than one public switch, because the same deck goes to different people on different days and one of those leaking should not have to turn the other off. Each link carries its own label and its own clock, and a link that has run out answers exactly as a guessed one does.

Arming the picker, clicking a heading and writing a note is how you tell an agent what is wrong with something it delivered, and it only ever worked on files hanging off a card. Folding presentations and decision pages into decks left the objects those notes were mostly about with no way to be marked up at all. Decks get the same feature now rather than a second one: the same picker, the same numbered rail, the same notes landing in a card's thread carrying a locator the agent can find again in the source. Review mode serves the deck unpaged, because a hidden slide has nowhere on screen to pin a note to and half a reviewer's notes would be unreachable. And a deck filed in a databank may have no card at all, so the composer asks which board to make one on and posts the note you have already written to it.

While somebody presented their screen you could switch to the grid, to a single speaker or to a sketch — it just would not stick. Swapping the shared window republishes the track, and for a moment the call contains no screen share at all, which read as a brand new presentation starting and yanked you back onto the screen you had deliberately left. It now records that you said no instead of inferring it from what is being published: choosing any other layout while a screen is up is kept as a refusal, and only asking for a screen again clears it. Opening your own sketch is deliberately not a refusal — it lands you on the canvas, and closing it still gives you back whatever is being presented.

A deck is stored exactly as it was written, which is the right contract and left every author inventing a palette, a type scale and their own idea of what a slide looks like — read three in a row and they were three products. A deck now arrives dressed in its team's design system: the colours, the fonts and the spacing come through as values the page can use, and nothing in that block paints anything by itself, so a deck written before any of this renders exactly as it did. The house layout is offered to whoever is writing rather than imposed on them. It defaults to dark because the product is, a slide and a page you scroll get different treatments rather than one narrow reading column, and a deck whose own document asks for a theme wins — the stored setting only decides when the page says nothing.

A deck finished on whatever slide the author stopped at, and the logo appeared only where somebody remembered to put one. Every presentation slide now carries a quiet watermark in its corner, and a single empty element ends the deck on a large mark with an entrance of its own. Neither is pasted in: the mark is built from the team's own brand tokens and resolved per team and per light or dark, so a team with its own logo gets theirs and not ours. The absence is the interesting half — a design that carries no mark gets no mark at all rather than falling back to ours, because putting our gem on somebody else's work is the one thing this must never do. A slide already carrying its own lockup can opt out.

Two ways of measuring a slide were wrong in opposite directions. A nineteen-slide deck opened in the databank previewer as a sixty-pixel postage stamp on an empty black stage, because content deliberately hanging past the edge of a slide was read as the slide being too big for the frame — and the same deck in a wide dialog looked fine, which is what made the report so hard to believe. Meanwhile a slide with more on it than fits reported that it fitted, so the excess was quietly cut off instead of scrolled: on one measured slide, 779 pixels of it were simply gone. A slide is now measured by what it is rather than by what overhangs it, a dense one grows and scrolls, and on a phone the deck's own controls shed their labels so two whole rows go back to the slide.

The navbar knew an agent was running and an open card drew its own pulse, while the board you were actually watching it work on showed nothing. The board's only notion of somebody being here came from an agent's writes, so an agent that spends ten minutes reading files, editing and running tests without writing anything back looked exactly like one that had stopped. A running session now counts as presence in its own right, on the card it is bound to, and the board hears about each start and stop on its own channel instead of waiting up to half a minute for the next sweep — a board reporting the bell's own fact thirty seconds late reads as broken rather than slow. The avatar is the button that opens the card.

The Workflow dropdown on a card offered seventeen recipes in four languages — every one from every team you belong to — and the Repository picker directly above it had the same problem. Both are worse than merely long. A recipe belonging to a team the picking agent's owner is not in resolves to nothing, so the card runs unguided; a repository from the wrong team makes the card undispatchable to every teammate whose board it sits on, and only you, being in both teams, see anything amiss. Each picker now offers what belongs to this board and nothing wider, without changing what you are permitted to see anywhere else. A card already pointing at something outside that list keeps it among the options, so a link made before this — or made by an agent — cannot be wiped by one stray click.

Renaming it was the only thing a board could be told about itself. So a board had nowhere to say what it was for, a board whose every card concerns one codebase had that repository attached card by card — which mostly means not at all — and there was nobody named to ask about it. One dialog now holds four things: a sentence under the name, a default repository so a card raised here arrives already attached to it, and a list of owners. Owners are deliberately not a permission: scope already decides who can see and edit a board, and letting a settings dropdown widen that would be a quiet way to hand out access. The picker offers the board's own assignee pool and nothing wider.

A decision page could distil one person's plate, and a single card could carry its own. The board — the unit people actually work in, and the one place a team's open questions sit together — had nothing between the two, so “what does this board need decided?” was a question you answered by reading forty cards. A board can now build its own deck: the same walkthrough, belonging to the board rather than to whoever asked for it, so any member of the team can answer it. Answers still land on the individual card they concern and unblock that card, not the other eleven. It has its own control beside the board's actions menu rather than three clicks inside it, and the number of decks still waiting rides on that control the way an unread count rides on the bell.

On a phone the board's bottom bar was one filter glyph, a wide gap, and two view toggles — so every filter sat two taps behind a menu, including the two people actually reach for, with an empty bar sitting right beside them. Three chips now live in that gap. They are the dimensions a chip can set on its own, so they need no menu and can simply be the bar; assignee, tags and priority stay behind the glyph, where a menu is the point. Blocked is a real filter rather than a shortcut — it combines with the others the same way every other dimension does, and it rides the address bar, so “what is stuck on this board” is a link you can send someone. A link written before it existed still opens.

A card with a perfectly good photograph on it could draw the browser's broken-image glyph across the top of its detail page. Three places decided what a cover was and they disagreed: the board and the attachment rail's Cover badge each took the first attachment that was actually an image, while the detail page took the first attachment of any kind — so on a card whose first file is a PDF or a document, the header pointed a picture frame at a document while the rail confidently badged something else. One rule decides now, and all three read it. The other half of the report is the header's own guard: a cover that fails to load is treated as no cover, so you get nothing rather than a glyph and a band of empty height standing over the title.

Move a card to another board and every image uploaded to it stopped loading. Nothing failed loudly — no error, no warning — and the card looked right everywhere except the one place it mattered, because the address of the stored bytes was worked out from where the card currently lives rather than remembered from where they were actually written. Moving a card changes that, so the address started naming a place nothing had ever been stored under. Where the bytes landed is recorded when they land now and read back exactly as written, so it survives the move — and rewriting a file lands on that same recorded address, which the old behaviour would have missed, quietly writing the new version somewhere nothing reads while the old one carried on serving.

Marking up a screenshot was something you could only do while reporting a problem — the picture had to be captured then and there. An image already attached to a card can now be marked up in place: an Annotate control on the tile opens the same stage, and you drop numbered pins onto the picture and write a note against each. Sending does two things on the same card. It uploads a copy with the badges burned into the image, at the picture's own size, and posts a comment carrying that copy inline with the notes underneath — so the annotation lands in the conversation that was already happening, readable by people and by agents alike, and the original picture stays untouched. Pins are held as percentages, so zooming never moves them.

Pasting a paragraph into a new card gets you a written headline with the full text kept as the description. Renaming an existing card by pasting the same paragraph did not — it clamped the sentence mid-word and left it there, because only the path that creates a card knew how to ask for a headline. Both paths do now. The line at which a title stops being a title and becomes prose moved up with it, from 120 characters to 140, set by measurement rather than taste: across two hundred real card titles the longest deliberately written one runs to 116, which left the old line four characters of headroom. Crossing that line does not trim your title, it rewrites the card, so it has to sit clear of what people actually type.

Answers to a decision page have always landed in the card's conversation. The question never did. The card said a decision page was attached and not one word of what it wanted decided, which meant anyone reading the thread — and any agent listing what needs attention — could see that a question existed without seeing the question. Linking a page onto a card now posts the ask itself: the goal, the questions numbered, and the options offered against each, with “free text” where it wants words. It is posted once even when several links land in the same moment, skipped for a page with nothing left to decide, and it never repeats a decision that belongs to a different card. The feed hands the questions over outright too, so a rerun stops re-explaining a card from scratch with options weaker than the ones already on the table.

Two objects had grown up separately and were the same object wearing different clothes: a built page, a way to look at it, and a way for people to add to it. That cost you two sidebar entries, two vocabularies and two of every control, and a change to one of them reached the other only if somebody remembered. They are decks now, of three kinds — presentation, decision and interactive — with a single index that filters by kind, status and scope where two separate pages stood. What each kind genuinely does differently is still different: a presentation gets its pager, and the kinds that collect answers get their rail. Nothing you already had moved or broke — the old addresses redirect into the new index, and the word Halfab now reads “decision deck” wherever a label is written.

An agent working with a built page had to know which of two families it was in before it could do anything: separate calls to create, list, read and update a presentation, and a parallel set carrying the same arguments for a decision page. Learning both was the price of touching either. There is one family now — create, list, read, update, delete, and the contribution call that posts an answer or adds to a collection — with the kind as an argument rather than as a fork in the catalogue. The old names still answer, so nothing written against them stopped working; they are aliases onto the same code rather than a second implementation kept alive beside it.

A deck is a snapshot of a situation, and the situation keeps moving — cards get retitled, re-described, moved, blocked and unblocked after the page was written, and nothing told you the page had aged. The only thing on offer was building another one, which starts a second page asking half the same questions and strands the answers already given on the first. A deck now reads its own freshness and, when its cards have genuinely moved on, offers an update you can hand straight to an agent. The rule is drawn narrowly on purpose, because an offer that fires on every twitch teaches you to ignore it: a finished deck never drifts, comments are not drift, and a card whose question you already answered does not count — answering unblocks that card, and reading that as drift would mean every answer aged the deck it was given to.

Handing an errand to an agent from a deep link ended with a line meant as a courtesy: the full brief is on my clipboard, ask me to paste it. An agent that reads a sentence like that does the polite thing. The receipt is in the report — handed a board's decision errand that had already named every tool it needed, the agent answered “I'll start by pulling the board — but first, please paste the full brief from your clipboard” and stopped. A courtesy had become a blocking question standing in front of work it had just been told how to do. The line is gone from all three kickoffs. The clipboard copy still happens, so you can still give an agent more if you want to; it simply no longer asks you to.

A deck's page announced “19 slides” and showed you none of them. The page was a fixed column — title, then details, then the description, then the deck taking whatever was left — and on a phone a real description is a paragraph. Measured on an ordinary handset the words took 380 pixels and the slides got 173; on a shorter phone they got nothing at all, which is what the report meant by the deck being hidden: the pager and the Present button were there, the slides were not. The deck is the content and the words about it are not, so the description clamps to two lines behind a Show more that appears only when it is actually hiding something, and the deck carries a floor it can never be squeezed below.

An embed put on a real site immediately wanted two things. It can now refuse anonymous reports: with that switch on, the widget still captures the screenshot and shows it to you — so you see exactly what you would be sending before deciding whether to sign in for it — and connecting lifts the gate in place, pins already dropped included, rather than throwing the report away and starting over. The real check is on the server, because the widget runs on somebody else's page and its own politeness is not a gate. The tab itself shrank to just the mark, 34 pixels of it, instead of the word Feedback running down the edge: on our own pages a labelled tab is fine, on someone else's it is our word competing with theirs.

Every way of making an event virtual built a room of the event's own. A team that spends all day in one channel was told to leave it for a fresh room per meeting — which strands the conversation away from the place holding the history that made the meeting worth having. A channel is a venue in its own right now. On a team calendar the venue picker grows an entry per channel, and picking one means the event has no room of its own: the channel is the room. An event holds one venue or the other and never both, so half the attendees can never end up in each. A channel is only offered where it could actually be opened — your own team's calendar, you still a member, the plan carrying chat — and a two-person thread is refused, because a private conversation between two people is not a venue.

A booking link is often the first thing anybody sees of us, and on a phone it was a page you scrolled: the month, then a column of times below it, then the time zone below that — so a stranger opening a shared link could not tell it offered any times at all without scrolling to find out. The month owns the screen now, and the times arrive as a sheet over it on the tap that asks for them, headed by the day written out, because a list of bare times over a covered calendar is exactly where a person books the wrong day. The card shed the height to make room: the host and the meeting's length moved up into the coloured band that had been carrying nothing but an avatar, and a month needing only five weeks stops reserving a sixth row of invisible buttons.

Ninety-six rows of quarter-hours, and the wheel did nothing to them. You could move the list with the arrow keys or by dragging its scrollbar and by no other means, which is a strange thing to discover halfway through booking something; it was reported in exactly those words. A dialog locks the page behind it against scrolling, and it does that by cancelling every wheel it cannot attribute to itself — and the time list opens in a layer that sits outside the dialog as far as that check is concerned, so its own scrolling was being cancelled as though it were the page. The list claims the wheel before the lock can see it now, while still holding back the scroll from chaining out to the page behind. The two other lists that open the same way, the attendee picker and a card's menus, were fixed with it.

A call announced itself twice when it started, and both announcements were events, which scroll away. Someone opening the app four minutes into a standup had no way to learn it was still going except by opening the room to look — the one thing you would only do if you already knew. The inbox carries what is live now rather than only what happened: the calls you could walk into sit at the very top, above everything else, because everything else will still be true in ten minutes and a room full of people will not. Each row says which room, whose team, and how many are actually in there — a count that matters more than it looks, since a call somebody started and left is still ringing, and joining is a different proposition when the answer is nobody.

One 44-pixel row was carrying the board's name, its workspace, its filters, the faces of everyone present, two view toggles and the whole actions menu. On a phone that row scrolls sideways, which means the name of the board you are looking at could be off the screen: the page had nowhere left to say what it was. It is two rows now, each with one job. Under the navigation bar: which board, whose workspace, and what you can do to the board itself. Along the bottom, in thumb reach where it was put on purpose: how you are looking at it — filters, view, and who else is here. That gives back 40 pixels the board had been given, which is worth being honest about, and it buys the thing that height was for, which is knowing where you are.

Search had a way in from everywhere in the app except the surface you spend the most time reading. A chat thread hides the floating search button on purpose, because the composer is pinned to that same corner and the button would end up over the textarea the first time somebody wrote a paragraph; it hands the gesture to the sidebar's own button and a keyboard shortcut instead. That is a complete answer on a desktop and no answer at all on a phone, where the thread is one pane, the sidebar is the other, and a touch keyboard has no such shortcut. The thread's header carries it now, beside the call button, opening the same panel rather than a second search. The line under the composer explaining Enter and Shift+Enter is gone on phones too — instructions for hardware that isn't there, spending one of the few lines a chat screen has.

Mobile Safari zooms the page in when you focus a field whose text is under 16 pixels, and it does not zoom back out afterwards — so the entire app was left scaled up until you pinched it back, on every input in the product, because the shared text field and the shared text area are both 12. Capping the viewport would have stopped it in one line and was never an option: that blocks pinch-zoom outright, which is an accessibility rule the app has written down in so many words. The fields meet the threshold instead, and only where the behaviour exists — a coarse pointer gets 16 pixels, a mouse keeps the compact size, and a narrow desktop window has no such behaviour and is left alone. Four places, which is all of them: the shared field and text area, plus the two chat composers that own their own.

The feed can show you the page a companion built, in a frame about eighteen rems tall. That is enough to know a page is there and not enough to read the thing it is asking you to decide from, so the honest move was always to leave the feed for the page's own address and then find your way back. Big screen opens the same card in a window that fits the page, with the questions in a column beside it and still answerable. Beside, not below: an answer that sits under a page you are scrolling is an answer you have to go looking for. It is the same state rather than a copy, so an answer given in the big window is already given when you close it — and only one frame is ever mounted, because two would both be talking to the same page.

A deck is a run of questions drawn from every team you are in at once, one after another, and each of them said only which card it was on. That is not enough to answer safely: the same words mean different things in different workspaces, and answering the right question for the wrong team is a mistake the surface was inviting. Every decision wears its card's team now, the same face that team wears everywhere else. The card's title opens the card too, rather than leaving for it — a deck is a run you are working through, and going off to a board to check one card means finding your place again afterwards. A modified click still gets you the ordinary link, because a new tab is the one thing a dialog cannot be.

The feed could hand a card to somebody, or raise it to the whole team. Between those sits the thing people want most often and had no control for: the card is already on the right person's plate, and you would like them to look at it. Assigning it again changes nothing, and escalating is a fire alarm for what is really a tap on the shoulder. Buzz moves nothing and decides nothing — it rings whoever holds the card, naming you and the card and linking straight to it, and leaves the card, its assignees and the feed exactly as they were. Two guards, and they are the same guard twice: it only reaches people who already hold the card, and never you. A nudge to somebody who was never given the work is not a nudge, it is an assignment nobody agreed to.

A decision page unblocks its card once every question has an answer, and a free-text question could only be answered by writing something. So one shrug-shaped question — anything you want me to do while this is parked? — kept a card open indefinitely, waiting on somebody who was already finished with it. There was no way to dismiss it, and there should not be: the answer is what the agent is waiting for. So there is a Nothing to add button beside Answer, and it sends an answer rather than dismissing the question, because “nothing, go ahead” is a decision and one the agent needs to hear. It posts to the card, reads back like any other answer, and can be changed afterwards.

Reporting something wrong with a page — capture it as you are seeing it, drop numbered pins on what is wrong, write a note against each — only worked on our own pages. The same tab can now sit on the edge of any site you run. You name the site, pick the board its reports land on, and copy a one-line snippet; visitors get the identical capture-and-pin flow, and their reports arrive as cards on that board tagged with the embed they came from. Which sites may use a key is checked on every call, so a copied snippet does not work from somewhere you did not name, and a visitor who wants their name on a report can connect their account through a first-party window without leaving the page they are reporting on.

Fit was supposed to scale a captured screenshot down into its frame. Instead the picture drew at full capture size and got clipped by the frame's edge, which on screen reads exactly as Fit not fitting. The frame was the right size all along; the pixels inside it were not. The library that takes the shot hands its canvas back wearing an inline width and height, an inline size outranks the class that was meant to scale it, and so the scaling quietly lost every time. It was intermittent for a reason worth writing down: a shot that needed cropping came back on a canvas we had made ourselves, with no inline size to lose to, and fitted perfectly — so whether you met the bug depended on whether the page happened to be scrolled to the top. What you submitted was never affected, only what you were looking at.

An agent that has just fixed a broken page had no way to look at the result of its own work: it could edit, commit and report success while the page was still returning a server error, because nothing it holds is a browser. It can now ask. One call, one path, and back comes the status, whether the page fell through to an error screen, and the title it painted. App pages only — anything under the interface or the sign-in routes is refused rather than probed. The same run fixed a check that was quietly lying: a canvas with 167 elements answered “167 element(s)” beside a list holding only the first slice of them, so an agent verifying its own layout got a confident, partial picture. The cap is now in the headline, in words, and in the description that never mentioned one.

Reviewing a file here means pinning notes onto it, and those notes anchor to the exact object they were left on. So delivering a corrected version — which meant uploading a new file and deleting the old one — destroyed the very annotations it was answering: six calls, and the conversation gone. A file in a databank and a file attached to a card can both be written over in place now. Same object, same links, same pinned notes, new bytes. A team is charged only the difference, so trading a 3 MB deck for a 3.1 MB one costs it 100 KB and shrinking one costs nothing. A failed upload leaves the previous version intact, and an attachment that merely points at a team's file is refused rather than followed — that file has one home, and a card that links it does not get to edit it.

Two habits were quietly expensive. Judging a card meant reading its brief and then its comments — two calls per card, so working through a column of forty ran to eighty. A card can now come back with its comments attached: the newest handful, or only the flagged ones, pulled out of a forty-nine-comment thread without paging through it first. Reading a file was the same story at a larger size. Five lines of contact details inside an 83 KB document meant pulling the whole document, and a saved web page whose bytes were mostly embedded fonts offered no way to ask for just the words. Now a dotted path returns the one subtree — and names the keys that do exist when it misses, so a miss costs nothing to resolve — and a page can be asked for its text with the scripts, styles and font payloads left behind.

Eight separate reports came from agents refused for input they had no way to know was wrong. A description over ten thousand characters was rejected by a tool that promised an over-long title would be handled and said nothing at all about the description, so “it copes with long input” read as covering both. A page-building call needed its html and a short note about it, and gave no hint which field the content belonged in. The rule arrived, every time, inside the rejection — after the work of composing something too big. The caps and the required fields are in the descriptions now, with the way out named beside them, and a few descriptions that overclaimed were corrected in the same pass: the call that returns every flagged comment no longer says it returns the open one, because a later reply may already have settled it.

The brief an agent gets when it picks up a card ended by telling it to move the card to the done column — a column that may not be called that, on a board whose titles carry no meaning an agent can read. So it guessed by name and hoped. Worse, a pinned card refuses to leave its lane at all, which made that final step simply impossible: the agent met a flat refusal with no sanctioned way past it, and either improvised or stopped. Both happened. The brief now says to read the board's real column titles first, and warns outright that the one meaning “in review” may be called something else entirely. It also names the sequence for a pinned card — unpin, move, pin again — with the reason, because a pin is about where a card sits in its lane, not a ruling that it may never advance.

A workflow is written by whoever had a particular set of tools connected. It is run by whichever agent picks the card up. Nothing reconciled the two, so one recipe prescribed three tools its agents did not have, and four separate runs by two different agents over a week each got deep enough to commit to the recipe before finding out — then filed the same complaint. A step can now declare the tools it needs, printed on the step where the work is and again before step one, while there is still time to act on it. And every recipe, declared or not, now carries the rule up front: if a step assumes a tool you do not have, say so on the card and stop, rather than improvising a substitute. Up front matters. Printed after the steps, it arrives once the agent has already started the ones it was meant to be sceptical about.

A standing card that runs every morning was having its push rejected every morning, and agents were inventing dated branch names by hand to get around it — thirteen reports, one of them five days consecutively. The cause was not the merge everyone blamed. A shallow clone fetches only the default branch, so yesterday's work branch was invisible even though it was sitting on the remote, and the checkout quietly started a new one from the wrong tip. The branch is fetched before it is checked out now, so a repeat run continues its own work instead of forking beside it. A fetch that fails for any other reason — a bad credential, a remote that is down — is raised rather than read as “this branch is new”, because branching off the tip and pushing over work somebody else left there is exactly what this exists to prevent.

Agents report the friction they run into, and those reports become cards. Forty-four of the hundred and thirty-one cards on that board were the same non-bug: a command exited non-zero and it was filed. But a non-zero exit is ordinary. A search says “nothing matched” that way, a probe for an optional file is supposed to miss, and a test suite exits non-zero precisely in order to report the failures it found. So the board filled with cards titled “Tool error” over bodies that were a directory listing, a search result printed back, and in one case a run that had plainly succeeded. A flagged result is now judged before it is filed, and anything that looks like the platform itself breaking — a missing command, a killed process, no space left on the disk — still wins over every reason to stay quiet.

Breaking a card into four self-contained subtasks and then handing one of them to an agent was refused four different ways: tagging it did nothing you could see, and the train, a direct request and a scheduled pickup each answered with a sentence about children travelling with their parent. The belief underneath was protecting something real — two agents in one repository, one on the parent and one on its child, writing over each other. But it was a rule about a hazard stated as a rule about hierarchy, and stated that way it cost the ordinary case. Now the hazard itself is what gets checked: a subtask can be picked up unless its parent has a run that is still going. A parent whose work has finished holds nothing back, and the subtask you dispatch gets its own branch and its own pull request.

Being online was worth nothing to a message aimed at you: it landed as a number on the bell, and reading it cost noticing that number, opening the popover and pressing reply. Now the arrival opens the dock. Every rule about which arrival earns that is deliberately narrow — unread only, never over a dock you already have open, never a conversation you have waved away, and never a reload spraying the corner with yesterday. Being named in a room counts too, because a notification from a channel here is written only for the people the message actually names, so it was never ambient chatter. The panel slides in and out instead of blinking into existence, and a reply you were halfway through no longer vanishes the moment you close it. If one room or one person is more than you want interrupting you, mute them: the messages still arrive and still count on the bell, but the corner stays shut.

The one-line summary at the top of a card is the first thing anybody reads about it, agents included. One card carried “I cannot retrieve the transcript because I can't access external websites” — short, clean, and the model answering for itself rather than describing the card. Nothing noticed, so it was stored and shown, and it argued the work was hopeless before anyone had tried. A summary that opens in the assistant's own voice is now thrown away rather than saved, whatever punctuation it wears: a comma, a dash and a colon after “sorry” all read the same. A card that is legitimately about something being impossible is untouched, because only the opening words are examined. And when there is no summarizer configured at all, you are told that plainly instead of being advised to retry something that cannot work.

On a very wide monitor a card page showed about three hundred pixels of dead margin, then the card, whose side panel ran out of things to say two thirds down and left a tall hole beneath it, then more dead space, then the conversation. Two holes with a card squeezed between them, and the holes turned out to be each other's fix. Past a certain width the page is three columns now: what the card is on the left — its lane, its people, its dates, its attachments and its connections — what it says in the middle, and what people have said about it on the right. The left column is welded to the page edge and runs the full height under the navbar, so one column fills the other's slack. Narrower screens keep the stacked layout they already had.

Adding a subtask from an open card was silent. The input cleared and nothing else happened until the round trip finished — and that round trip is not short, because the new card's one-line summary gets written before the server answers. The only sign anything had been submitted was the row eventually turning up. It behaves like the board's own column composer now: a pending row appears the moment you press Add, with a spinner on the button while anything is still in flight. The placeholder shows the headline the card is actually going to get rather than echoing back the paragraph you pasted, since a long paste becomes a title plus a description on the way in and promising you a card nobody is about to make would be worse than saying nothing.

Sharing a way to book time with you meant sharing your handle. That is fine for a colleague and awkward for everyone else: it is a name you picked, it sits in the middle of the link, and once it is out you cannot take it back without renaming yourself everywhere. Every booking page and every meeting type now also answers to an unguessable id — one link to your whole booking flow, another to a single meeting type with no handle in it at all. Both are permanent, both sit beside the readable version in your settings with a copy button each, and both land on exactly the same page. So you can hand the anonymous one to a stranger and keep the readable one for people who already know your name.

Two pages here get opened by people with no account: a meeting link and a booking link. The meeting one arrived with the whole app navigation across the top — five icons, most of which lead nowhere for a guest, and all of which invite them to wander off instead of joining. The booking one had a look of its own, a bordered panel and a small line of credit at the bottom doing a job the mark does better. Both share one composition now: the mark over the card with the wordmark beneath it, a band carrying the team's colours, and the hosts' faces hung over its seam. A host's uploaded banner becomes that band rather than a full-width strip, and the receipt a guest gets after booking is dressed the same way — so the pages in that flow finally look like one product rather than three.

A meeting room had five things in it: microphone, camera, screen share, chat, leave. Slides were not among them, so a host with a deck either shared their screen — a video of a document, unreadable on a phone — or ran the meeting somewhere else. A host can put a deck on the stage now, and the room follows their slides: the faces move to a rail beside it, or a strip above it on a phone, and anyone can read ahead quietly and jump back to wherever the host is. The hard part was that half the room may have no account at all. So the meeting serves the one deck its own invitation names and nothing else — a guest's pass means “the deck in this room”, never “any deck, if you know its id”.

A meeting link opened saying one time and then changed it. An eight o'clock meeting in Amsterdam painted as six in the morning and flipped to eight a moment later, once the page had finished loading — and left the wrong one on screen for anyone whose connection was slow or whose scripts were blocked. Link previews never run scripts at all, so an invitation unfurled in a chat window could read “Join meeting · 6:00 AM”. That is a meeting missed by two hours, on the one page strangers open. The hour is now worked out in the meeting's own timezone before the page is sent, so the very first paint is right, with the zone named beside it, and what a preview captures agrees with what you see.

Knocking at a public meeting room was only ever answered from inside it. So once the hosts had gone, a guest sat on “waiting for someone to let you in…” — the same sentence a busy room shows — asking again every three seconds for a week, until the knock was swept away. And a guest still standing there when the room emptied was told they had not been let in this time, which blames a host for what an empty room did, with no way back. The door now knows whether anyone is in there who could admit them, and says which wait it is. When a room ends, the knocks left at it are settled rather than left hanging. Reloading your tab no longer costs you a pass you already hold — an admission is bounded by its own clock, not by a dropped connection.

A feedback card lands in front of somebody who was not there and cannot ask a follow-up — usually not even a member of the board it lands on. It already carried the page, the window size and who sent it. It did not carry the one fact that decides whether anyone can reproduce the problem: “the menu overlaps” is a different bug in Safari than in Chrome, and “I can still scroll” means something else on a phone than on a desktop. The browser, the operating system and the device are read from the request now rather than asked for, and the screen's pixel density comes along too, because the same “390 × 844” is a different picture at one times and at three. The screenshot itself was fixed in the same pass: swipe past the first column of a board on a phone and the shot used to come back as a navbar, a toolbar, and nothing in between.

On a card with nothing attached and nothing linked, two panels contradicted each other. “Nothing attached yet” sat directly above “everything linked to this card is already listed above”, the second sending you back to the first to look for things that do not exist. The claim fired whenever the card had any relation at all, and every card has one: the board it lives on. Being part of something is not being connected to it, and nobody reading a panel titled “Also connected” counts the breadcrumb as a connection. So the sentence now appears only when there really is a link being rendered somewhere else on the page, and an empty card's panel says nothing rather than something untrue.

The navbar already spends two corners on dots — red for unread, amber for something that needs you — so a third dot could only have meant “something else”. The bottom-right corner is a small robot now, bobbing on its own loop while an agent is working and tinted with the colour of the team it is working for, so the mark says whose run it is without needing a legend. The rows underneath say it too, and every one of them is clickable at last, including a teammate's hand-run agent — a row that reported work you could watch happening and then refused the click. It takes you to that team's live feed, and once you are there the controls offered are only the ones that can work for you: a permalink into somebody else's session, which could only ever have failed, is simply not shown. The count no longer reads itself out on every page you visit, either.

Opening an image in a chat thread let you step through the other images in that one message and no further, while a document or a PDF never reached the viewer at all — it sent you off to its own page instead. Sketches and card attachments have handed the viewer their whole collection for a while; chat had not. The conversation is one ring now, oldest first, and whichever file you open starts you at its own place in it. Markdown, text, HTML, PDFs and video ride the ring beside the images and open where you are rather than navigating away, so going back through what a thread has collected is arrow-key work instead of a trip through a folder.

A chat notification had exactly one thing you could do with it: follow it to the team's chat page. Answering with one word therefore cost you your place in whatever you were reading, which is a lot to spend on “on it”. The row grows a reply button now, and the reply happens where you already are — a narrow column in the corner holding the same thread the chat page would have shown you, with the same message list, the same composer and the same live updates. It is not a second, smaller chat with its own bugs to keep in step; it is that conversation in a smaller frame. Close it and you have not moved.

Clicking somebody's tile in a call did nothing — not in the grid, not in speaker view, not in the filmstrip along the bottom where you would most expect it to. Not the wrong thing, either: a camera tile has never had a click target anywhere in the app. A click puts that person on the stage now, the way a shared screen, a canvas or a deck takes it, and everyone else drops into the strip below them. It is your view and nobody else's, so you can watch whoever you like without moving anybody's picture around, and clicking the same face again gives the grid back. Something actually being shared still outranks a face, because that is the thing the room is looking at together.

A guest joining by link met a call that looked nothing like the ones inside: letterboxed tiles with hard edges, no room name, nothing to say who else was live, and a row of wide labelled buttons where every other call here has a floating pill. It was a different video conference sharing the domain. The reason behind it was sound — a stranger has no business near the sketchpad, the decks or the agents — and that isolation stays; the disguise is what went. A public room renders on the same stage as a team call now, with the same tiles, the same name across the top and the same controls, so the five things a guest can do look like this product doing them.

A board worked out whose cards were whose only after it reached your browser, and that had two consequences you could see. The “My cards” chip popped in a moment late and shuffled the filter row as it arrived, and the whole board was thrown out and rebuilt on landing, which left the menu on each card briefly unresponsive. The worse one: a link you shared with that filter already applied opened on an empty board — “0 of 4” — before refilling itself a beat later, which reads as a broken link rather than a slow one. Who you are is known when the page is built now, so the chip is there in the first byte and a shared filtered link shows the right cards immediately.

A month on a phone gives each day about fifty pixels of line, and the mark on it was either the hour or the title, never both. Timed appointments therefore showed their hour and their name never appeared at all — which is backwards for the thing you are scanning a month to find. The space to fix it was already in the cell: a day with one or two events leaves most of its height empty. So a quiet day stacks now. The hour keeps its line, and the title gets one of its own underneath at full width with nothing beside it to pay for — roughly nine characters instead of five, which is the difference between “9a” and “Standup”. A busy day still packs, because there the count is the point.

Sixteen pages here are built to be exactly one screen tall and not to scroll, with the lanes and lists inside them doing their own scrolling. Each of them reserved the navbar's height and forgot the single pixel of border it paints underneath, so the document came out one pixel taller than the screen — which is all it takes to make the whole page scrollable. What that meant on a phone: a drag begun anywhere outside a list, the navbar being the obvious place, hauled the page and the browser's address bar along with it. The height is worked out in one place now instead of being corrected by hand in ten, so the board, the calendar, the timeline, team chat, sketches and their loading screens all sit still.

A team's storage allowance is measured over the databanks that belong to the team, and every individual upload is checked against it. Moving a whole databank in was not, which made a personal one an off-books staging area: put the files somewhere private, then move the container across and the bytes landed on the team's ledger for free, past a ceiling every one of them should have cleared on the way in. The move is charged now, and refused if it would not fit — the container stays where it was rather than half-arriving. Nothing meters personal storage and nothing here starts to; this is the same allowance being applied in the one place it was quietly skipped.

A meeting link is the one page here that strangers open, and until now it opened on an unsigned grey card and unfurled in chat as the bare word "Meeting". The door wears the invitation now: the team's gradient across the top, its face in the corner, the hosts' portraits hung over the seam, and the join button in the team's own colour. Paste the link anywhere that unfurls and the preview says which meeting, whose team, and when, with the team's face as the thumbnail — but only for a public room; an internal one still tells a stranger nothing, and neither is ever indexed. The pass got stricter while we were in there: a guest you admit to a recurring meeting holds a ticket good for a few hours rather than a standing key to every future occurrence, and you can turn one back out from the lobby.

Making an appointment meant naming it and picking a time; where it happens and who it belongs to had to live in the description. Three fields carry that now. You can move an event between your own calendar and a team's after it exists rather than only when you create it, and both audiences see it leave and arrive immediately. A location field completes real addresses as you type, keeps an open-in-Maps link beside them and folds out a small map under the form. And an appointment can have its own video room: internal admits anyone who can see the calendar, public lets someone with no account knock at a lobby and wait for a member to let them in. One room serves a whole repeating series, so the standing link in a weekly invite keeps working.

A day cell on a phone is about 53 by 87 pixels, and it was spending a third of that on a date number above a row of anonymous dots — a personal event and a team's read as the same indigo speck, so the month told you something was happening and nothing else. Each day now shows up to three marks that name what they belong to beside the hour it starts: the team's face, the card glyph for a scheduled pickup, the bot for an agent point, a warning triangle for a run waiting on a person. Past three, the last row spends itself on "+2" instead of dropping events silently. The week view got the same attention: a red line at the current minute, an opening scroll that puts now a third down the screen, and a click on an empty slot that arrives with that hour already filled in.

Connecting an agent used to mean registering it first: the client asked us for an id, we minted one, and everything downstream hung off that record. This year's protocol revision replaces the dance with a document — the client points at an https address that describes itself, and the endpoint fetches it, checks it and treats it as the client. Nothing you already have connected changes, and anything registered the old way keeps its id. The fetch is treated as hostile, because whoever calls chooses the address: https only, no local or private hosts, no redirects, a three-second limit, a small size cap, and the document has to name the same address it was served from. A client that fails any of that is refused at the door in plain words rather than sent back to somewhere it named for itself.

Every task tool told agents the same thing in its own description — give me the task and I will work out which board it lives on — and then refused the call for not naming the board. Twenty of them did this, so an agent paid a failed round trip for an argument the server was about to compute for itself, and moving a card between boards failed outright. The board is optional now wherever a task is named, and a test holds that rule for every tool written later instead of leaving it to whoever types the next schema. Asking a human to decide something got the same treatment: it takes the short ids you actually hold rather than raw internal ones, and creating a subtask needs neither a board nor a column, because the parent card already answers both.

The navbar carried two status buttons that never referenced each other — a bell for notifications and a bot for live companions — so "did my agent do the thing?" was a question you asked in two places, and neither one could take you to the session doing it. The bell is the only status control now. A Working now block sits at the top of the same list finished work lands in, every live row is a link into that session, and a notification an agent wrote wears that agent's mark, which is what makes a bare one mean a person. The bell rings with a green dot while something is running, and a row that arrives while you are watching slides in behind a ring. What needs you moved in too: a card at the top counts it, names the loudest item and opens the attention page, with an amber count on the button itself.

On a wide screen the attention page was a narrow document with about 290 pixels of margin either side and its controls crammed into the top-right corner of the header — where, once you had a deck, the strip ran out past the feed and under the side rail. It wears the shape the taskboard and the databank hub already wear now: one full-height column, two panes that scroll themselves instead of sharing the page's scrollbar, and every page-level control folded into a bar pinned along the bottom edge — the deck, the scope toggle, the buddy switch, and the tally on the right. The headline stopped over-promising, too. It used to count the asks on screen against a total taken before the display cap, so a busy feed advertised ten cards that were not on it; it counts what you can actually see, and the cap now says 40 of 50 in its own words.

Scrolling a long feed is the slow way to take it in. Carousel, beside the deck controls, puts the same feed on a stage: arrow keys or h and l to flip, a swipe on touch, the strip along the bottom to jump, Enter to open the card, Esc to leave. It is the page's own list in the page's own order — asks first, then everything else — so the third card is the third card either way, and every slide carries what that card actually wants from you: an ask arrives with its answer buttons and composer intact, a card that only needs a look arrives with its facts and its unblock and reschedule row. Answering does not throw you out. The feed re-reads, the answered card leaves it, and your place holds, so the next thing waiting slides in under the same finger.

Everything on the attention page could be answered, unblocked or opened — but not given to somebody else, and there was no way to say that one of them is on fire. Both are there now, on every kind of row. Assign opens the board's own member list, and handing a card to someone takes it off your feed, because a card with an attendant is no longer unattended work; the team view and the everything view keep the full picture, with the assignee's face on the card. Escalate posts a red line into the team's chat with the card as a real mention and keeps it on the team's escalated list until someone stands it down — from the card, the chat rail, or a call, where Escalated joins chat and transcript in the side pane under the e key, each one offering a ping that flashes a banner over every participant's screen.

A phone browser retracts its address bar only when the document scrolls, and the databanks shell pinned itself to exactly the height of the visible window with every pixel of content inside an inner scroller — so the document never scrolled, the bar never hid, and you lost 60 to 100 pixels of screen for a whole session with no gesture that could win it back. Below the desktop breakpoint the document owns the scroll now; from there up nothing moved. The other half of the same report was the stuck feeling when a list reached its end: the gesture chained outward and rubber-banded against a shell that cannot move, and on Android it armed pull-to-refresh. Every scroller in that shell and in the task toolbars keeps its own gesture now, so a list that has run out simply stops.

A category axis was inheriting the label-thinning that suits a numeric one. Dropping a tick from a ruler only makes the ruler coarser; dropping one from a bar chart deletes a bar's only name. A chart of twenty-four platforms drew seventeen labels, and one of the seven it swallowed was the third-largest bar on it — so a reader comparing them got a confidently wrong answer from something that looked authoritative. Category labels are never thinned now, as a rule for all forty-four chart shapes rather than a nudge to the one that showed the problem. Refusing to thin only helps if the labels then fit, so each category is told how much room it owns along its axis and the text is sized, angled or wrapped to live inside it.

Every kind of thing a databank holds is plural in its address — knowledge bundles, mindwalks, presentations, charts, workflows, halfabs — except memos, which sat at the singular. The sidebar calls it Memos and the page titles itself Memos, so the only spelling anyone would guess was the one that came back empty. It lives at the plural now and three old spellings redirect into it, including the one your existing agent receipts and task comments already point at. The objects rail got honest about itself too: eight of its entries keep the rail and five carry you out of the hub entirely, which you learned by clicking and losing your place. They are two groups now, and the ones that leave say so. On the databank pages, the tip that used to run underneath the floating search button gets out from under it.

The card page was the only route here with no title of its own, so it fell through to the site's marketing line: six open task tabs read identically, every bookmark saved under the same name, and browser history could not be searched by the thing it pointed at — which matters more here than most places, because that address is the one people paste to each other and the one agents link back to. A tab carries the task's own title now, and a board's tab carries the board's name instead of a flat Tasks. It costs nothing to open: naming the tab reuses the read the page was already making rather than quietly running every query twice.

On a card's own page the comment thread was a column boxed inside the card's scroll body, sharing its width with the connections rail. On a wide screen it leaves the card altogether: a full-height rail welded to the right edge of the window, running from under the navbar to the bottom of the page, with the label row and the composer fixed top and bottom and only the messages moving between them. The card sits beside it. The board's card dialog is untouched, and so is every narrower window. Two things fell out of the move — the floating search button no longer lands on top of the composer on that page, and the Attached list stopped painting a databank's name across a file's size, which used to shave a file name down to five letters and an ellipsis.

The agent endpoint now serves MCP revision 2026-07-28 natively, and everything you already have connected keeps working exactly as before — one endpoint, one tool catalog, both protocol generations. What the new revision buys you: tool catalogs now say how long a client may cache them, and every response names the server version it came from — so the old failure where a long-connected agent silently ignored a parameter behind a stale catalog finally has a protocol-level cure instead of a reconnect ritual. An agent that hits a decision it must not make alone can now wait for your answer inside the same call: request_human_review hands you the card, you answer on the thread or /attention as usual, and the agent's call completes with your reply the moment it lands. And instead of polling a board for changes, an agent can hold one quiet stream that wakes when something actually happens. Under the hood, the OAuth flow picked up this revision's security hardening too (authorization responses now prove which server issued them). One housekeeping note: the long-deprecated /api/mcp/sse path is retired — if you have an ancient connector config pointing there, repoint it at /mcp.

Asking for an attention deck used to paste your whole feed into the brief — every waiting card, every flag — and because there is a ceiling on what an agent can be handed in one go, a busy morning was exactly when it started shortening: each card's context narrowed, then cards dropped off the bottom altogether. All of that to hand a connected agent something it could already read. The brief now points at the feed instead of carrying it: your agent asks for what is waiting when it actually sits down to build, so nothing is clipped, nothing was cut to fit, and a card that arrived (or got answered) between pressing the button and the page being built is counted as it stands. What it reads is the same list you see — loudest first, each card with its ask, why it is on your list, and the ones an open deck already asks about marked as spoken for. Same button, same page; the only difference is that a busy plate no longer produces the thinnest deck.

Asking for an attention deck used to brief the agent on your whole feed, whether or not a deck you already had open was asking the same questions — so the second deck restated the first, and answering something twice was the only way through. "New deck" is now built from what is genuinely new: the cards no open deck already asks about. The button says how many that is ("New deck · 3 new"), the brief tells the agent which items it deliberately left out and which deck already holds them, and a card you've answered on an open deck frees itself again — so it comes back as new material rather than being permanently spoken for. When everything waiting really is covered, the button stops pretending and becomes "Rebuild deck", which briefs the whole feed because you asked for that on purpose. And no deck is stranded any more: "Older decks" beside the banner lists every deck you've had, the still-open ones first with their progress ("1 of 2 decided"), so a deck you half-answered — or one that aged out of the banner after a week — opens in the same walkthrough and its answers still land on their own cards. The banner itself got less brittle too: when the newest deck's remaining decisions all point at cards that have since vanished, an older deck that can still be answered steps up instead of the banner going dark.

Handing a card to a local agent went through the same menu every single time: open it, read the same four apps, pick the one you picked yesterday. The choice is remembered now. Once you've handed something to Claude Code, every "Open in" here becomes a split button — "Open in Claude Code", with its own mark, one click — and the chevron beside it still opens the whole list, where the app you last used is marked so it's clear why that's the one on the button. It's one habit rather than one per surface: the task card, the attention deck, "Get a page for this" beside anything waiting on you, a column's cleanup and a dogfood bowl all prefill the same app, and switching is a single pick that every one of them then follows. The list keeps its order instead of reshuffling under your eye, and before your first hand-off it's the plain "Open in" it always was.

Test-group members have a way to report a problem without leaving the thing they are reporting on. A slim tab welded to the right edge of the window opens a card holding a picture of the page exactly as you are looking at it, scrolled where you scrolled, with a comment box and click-to-pin notes you can drop on the exact spots you mean, numbered as you place them. What you send files as a real card on a board the platform team works, the pins burned into the screenshot and written out underneath alongside the address you were on and the size of the window you were using. The tab sits above everything, an open dialog included, because a dialog is exactly the kind of surface most worth complaining about. A platform admin enrols people, or whole teams, from the admin pages.

Databanks kept no accounting at all: a team could store bytes until the disk noticed, and nothing here could answer how much a team was actually using. Every image and file in a team's databanks counts toward one number now — team chat files and finished call transcripts included, since those are already filed there, while a card that references a databank file copies nothing and is never counted twice. A team can see how full it is, and an upload that will not fit is refused before it starts, whether it comes from the web form, an agent's upload tool, a sketch drop or a chat share. One exemption is deliberate: a finished call transcript is the only copy of something that already happened, so it is stored even if it nudges a team past its line, and the next upload someone actually asks for is where they read the message.

The board's bottom-right menu had grown a row for every team you own — new team taskboard, repeated down the list — while two keyboard-first actions sat outside it as bare glyphs nobody could name. Both halves moved. Jump to card and Keyboard shortcuts are named rows in the menu now, each showing its key, and the shortcuts row is reachable on a phone for the first time. The per-team rows are gone: one New taskboard entry opens a dialog with a workspace picker, so the menu stays the same size whether you own one team or nine. The picker opens on the workspace you are creating from and falls back to Personal when you could not create there anyway, rather than letting you fill in a form the server was always going to refuse.

Some choices can't be made from a sentence. "Which layout?" needs the two layouts in front of you; "this shade or that one" needs the shades. A halfab is the new object for exactly that moment — a half-fabricate: a small page a companion builds not to deliver something but to get something, with the choice depicted (the mockups side by side, the trade-off in a table) and the decisions declared beside it, each with its simplified answers. Those answers are buttons wherever the halfab meets you: on its own page, in the databank grid, on the card it belongs to, and on /attention, where an undecided halfab surfaces by itself with the goal as the headline. The page can even offer the choice inline — click a mockup and the app asks you to confirm — but the page only ever proposes; the click that counts happens in the app's own chrome, because the page was written by the very agent waiting on the answer. And the answer goes where the agent is looking: posted onto the card's thread in the agent's own words, with the last decision unblocking a blocked card so the work carries on. You can also ask for one: anything waiting on you on /attention now carries "Get a page for this", which hands the job either to a local agent (the brief lands on your clipboard and opens Claude, Claude Code or Codex) or straight to one of your auto-agents, which goes and looks at the real thing and files the page back onto the card. And the whole feed distills too: ask for your ATTENTION DECK — one halfab with a slide per waiting card, each decision bound to its own card — and it appears as a banner on /attention, opening in a dialog you can walk straight through. Every answer lands on its own card's thread and unblocks that card alone; answered slides dim and wear their check as you go, until the deck closes itself on the last one and the page says you're all caught up.

Every AI feature here accounted for itself, and the two that mattered most didn't: the live call transcriber — the thing a team switches on and pays for by the minute — recorded nothing at all, and the automatic TL;DRs counted tokens with no price attached. Answering "what does this cost us" meant reading three different shapes and adding them up by hand. Now every billable model call writes one row to one ledger, and your team's overview page reads it back: the transcriber, voice-memo transcription, the actionables a call or a memo produces, the TL;DRs written for cards and comments, the sketch assistant, and the dogfood bowls — each with what it was about and whose bill it lands on. Where a model has no published rate the row says unknown rather than guessing a zero, so the total prints as "≥ $0.05 across 3 calls" with the unpriced ones counted beside it and a floor never reads as the answer.

A booking page had one set of rules for everything on it: one week of hours, one notice period, one horizon. So "intro calls on Tuesday afternoons only" and "I'm away next week" were both things you simply could not say. Both are sayable now. Any meeting type can keep its own week of hours instead of following the page's, and its row wears "Own hours" so an override is never invisible. Time off is a list you add to, either shutting the whole page or only one meeting type — and a block is one continuous span rather than the same hours repeated across a range, so "away Friday 15:00 until Monday noon" means exactly that, and it stays where you wrote it when you travel. The public page recomputes from all of it: a page-wide 11:00–15:00 block leaves 09:00–10:30 and 15:00–16:30 bookable, and the 10:30 slot survives because it ends exactly where the block starts.

Typing the exact name of something you already know exists could still leave it third, under its own kind, below loose matches from other kinds — the ranking fused its arms by position alone, so every arm's best hit tied, and the team you happen to be standing in nudged its own vaguer matches ahead of another team's perfect one. Literal matches lead now. Search grades each result's title against what you typed — exact, then starts-with, then the whole phrase, then the words — and everything that matches literally ranks above everything that only matches in spirit, whichever team it belongs to. The launcher gathers them into a Top hits group of up to five above the usual kind groups, each row badged with what it is, and the preview rail names the reason it is there — "Exact match", "Title starts with it" — instead of the machinery that found it.

A companion that stops for a person used to leave a flag that /attention showed as one truncated italic line under a row of badges; learning what was actually being asked meant opening the card, and saying yes meant finding a composer. The page now leads with the asks. Each is a card: who asked and when, the one question in plain words, the answers as buttons when the decision is a yes/no or a pick-one, a reply box for everything else, and the full ask one click away. Answering posts to the card's thread and unblocks it in the same breath, so the agent can carry on — the same buttons sit on the card's own thread. Agents can spell the ask out (request_human_review and attention comments take a question and options), and for everything written in prose the ask is read out of the text — the question sentence, an (a) … (b) … list, an "X or Y?", the usual yes/no shapes — conservatively, so a wrong button never appears where a reply box should. The long TL;DR of an attention comment is now generated as the question to answer rather than a report about it. Everything else that merely needs a look sits underneath in words instead of badges — "Blocked · Overdue — was due Aug 20 · Roadmap › Doing" — with Unblock and Due today / Tomorrow right on the row, and the side panels only appear when they have something to say.

Your calendar now has a public face. Open Calendar → Booking link and you get a page at /b/<your-handle> that anyone can open, signed in or not: they see a month of the days you have time, pick a day, pick a time, leave their name, email and a note, and the meeting lands on your calendar as a real event — titled for them, their details in its description — and that time goes off the page for everyone else. "Free" is computed live: your weekly hours (per weekday, in your own time zone, split however your days split) minus everything already on the calendars you can see — your own, your teams', a linked Google calendar — with a minimum notice, a horizon, and an optional buffer around each meeting. Under the general link, meeting types make the specialised ones: "Intro call, 20 minutes" is /b/you/intro-call, with its own description and where-it-happens; the general link lists them all (or goes straight in when there is one). Share it as part of a team — /b/<team>/<you> for any team you belong to, picked right on the link card — and the same page wears that team's gradient and face beside yours. The page wears your look, not the app's — a banner, an accent color, light or dark — and the host side lives in the calendar: pause the link, change the handle, edit hours and rules, add or retire meeting types, and see who is coming, with a cancel that frees the slot. The visitor gets a confirmation page with an add-to-calendar file and a link to manage or cancel; times show in their zone, switchable, and two people racing for one slot get one booking and one polite no.

The connections were always there — a chart cited by four cards, filed in a databank, pinned onto a canvas — but each one was only ever read from one end. Stand on the chart's own page and there was no sign of any of it. Now there is. Charts, tables, workspaces, decks, knowledge bundles, recipes and databank files carry a panel of what they are connected to, drawn as rings around the thing you are looking at, and a card gains an "Also connected" section for the links its attachments and subtasks don't already show. A sketch gets the same as a sheet, because a canvas has no room for a panel. Anything you are not allowed to see is simply absent — not greyed out, not counted as a hidden item, because an edge off someone else's card was never a fact you were told.

A SimpleTable's name and description could be set the moment it was created and never again over MCP. That bit hardest on the description, which is where you say what the data does and does not cover — and coverage is something you learn after the rows arrive, not before. One table here holds 83 of 119 month-by-provider cells because its sources publish snapshots rather than a feed, and that caveat ended up scattered across a bundle, a storyboard panel and a card comment, none of which travel with the table. An agent can now rewrite both in place. The short link stays fixed, because that is what other objects resolve against and changing it would strand them; and a wording change deliberately does not count as a change to the data, so fixing a typo can't invalidate every chart snapshot pinned to the table.

Chat would tell you someone was offline and stop there, which answers the wrong question: whether to bother messaging somebody depends on when they were last here. Members now read "online" or "last seen 2h ago", with the exact time under the pointer. Nothing new is being watched to do it — every board, canvas and chat already sends a quiet heartbeat so a closed tab fades out on its own, and that heartbeat was simply being thrown away. It is kept now, from all three, so being on a taskboard counts the same as having the chat open, and a thirty-person team costs exactly the same to read as a two-person one. It expires after thirty days on purpose: past that the honest answer is "offline", not a date from last spring.

A presentation opened in the previewer as a web page — technically true and useless as an answer: slide one, a Present button, a view-source toggle, and no way to reach slide two. A deck's whole nature is that it has slides. It now previews through the same viewer the deck's own page and the call stage use, with its pager, slide counter, slide list and Present, everywhere a deck turns up: the databank grid, the all-content sheet, the picker, a card's attachments, and the sketch canvas — where a placed deck couldn't be previewed at all, so reading it meant leaving the board. Inside a preview the arrow keys keep walking the ring of things you are paging through, so the deck pages from its own ‹ › buttons instead: two things can't own one key.

Three things went wrong with calls on a phone, and all three are fixed. Turning on the blocky camera veil stretched you sideways — the sampler drew your whole frame into the tile's grid, and a phone's tile is wide while a phone's camera is tall, so a portrait feed came out nearly three times too wide. It crops to the middle now, framing the veil the way the clear tile frames the video it stands in for. A long slide title in a call's deck wrapped onto its own line and pushed the Slides / Present / Original row onto a third, taking 28 pixels off every slide; the pager holds one row now, whatever the title. And expanding a call let the page carry on scrolling behind it, which on iOS also left the controls below the bottom of the screen — the call measures to the visible viewport now and holds the page still while it is open.

Typing the whole thought into "Add a card" was meant to keep the long version and take a scannable headline off the front of it. In practice the split only happened above the length the title can physically hold, so a 178-character sentence sailed through and became its own "title" — and when a split did happen, the title was the first 120 characters of your text with the rest cut off, which is a truncation, not a headline. Anything past a headline's length now reads as prose: your text is kept in full as the description, and the title is a real headline written for it, arriving alongside the TL;DR that was being written anyway rather than costing a second wait. Lead with your own headline on the first line and that still wins, and renaming a card never generates anything.

A team object was visible to everyone in the team — that was the whole rule — so an owner who wanted a sketch, a file or a deck seen by three people rather than thirty had exactly one lever: move it back to personal and hide it from everybody. Now you can name the few. The lock on a sketch, a databank, an item card, a knowledge bundle, a workspace, a deck, an artifact, a repository or a recipe opens a list of people from that team, and everyone off the list loses it everywhere — every listing, every search result, every direct link, and the file's own bytes. Owners and admins get no exemption, because restricting something has to mean it even from the person you are restricting it from. You never lose your own object, and moving it to another team clears the list, since those people were named out of a roster that no longer applies.

The databanks landing was a grid of containers and a row of five chips pointing elsewhere, and the one question it couldn't answer was the one you arrive with most mornings: what's new in here, anywhere? Open it now and that is what you get — every item across every databank you can see, on one sheet: files and images, sketches, bundles, cards, tables and charts, decks, recipes, repositories, artifacts — sorted by whatever moved most recently, with the databank (and the folder) it lives in beside each row. Sort by name, kind, size, when it was added or last touched, or which databank; narrow by kind, by databank, by who filed it (a person, or a companion over MCP), or by a word from a name or a tag; page through the lot fifty at a time. A click reads the row in the pane beside the sheet and ←/→ walks the rest, and the URL carries the view, so /databanks?kind=presentation&by=agent is a link you can hand a teammate. The containers are still there, one tab over, with their grid and their sortable list. And the whole area gained a sidebar on the left — a sheet on a phone — with the workspace's content by kind (a click is the filter), every databank (a click opens it, New right beside them), and the index pages for every kind of object: knowledge bundles, sketches, taskboards, SimpleTable, charts, presentations, workflows, repositories, the auto-agent console, companions, memos and mindwalks. It folds to a strip when a wall of tiles or a docked preview wants the width back, and remembers that you folded it.

Almost every deck here is written by a companion — you ask for one, it makes it. Those were precisely the decks you could not open: the presentations index and the deck's own page both came back as a bare server error, while a deck you had built yourself opened fine. That split is why it lasted as long as it did, since every deck made while the feature was being built carried a person's name. What the pages were choking on was the small credit line naming who wrote a deck and with which model: for a companion it reached for a hover card that neither presentations page had set up, and reaching for one that isn't there brings the page down rather than skipping the hint. The credit now rides in the plain tooltip any browser will show you, so it still says the companion and the model, and both pages load.

Ask a companion for a deck and you used to get an .html file: it downloaded instead of opening, it scrolled instead of paging, and showing it to anyone meant screen-sharing a browser tab. A presentation is now its own object. It is still just HTML — your own styles, fonts and scripts, kept exactly as written — but the app reads it under presentation rules: one slide at a time, arrow keys and swipe, a slide rail that lists every slide by its heading, and a Present button that fills the screen. Mark slides with <section class="slide">; if you don't, we find them anyway — from <hr> separators, or from repeated headings — and a deck that already paginates itself is left alone. Any HTML file already sitting in a databank turns into one with a click, which is also how a deck too big to paste gets in. File a deck in a databank, link it to a card, hand a companion the id: it behaves like every other object here. And on a team call, put it on the stage: everyone follows your slides, anyone can read ahead without interrupting you, one tap puts them back with the room, and someone joining ten minutes late opens on the slide you're actually discussing.

Visit the agents page, or the recipes index, or your repository settings, then click through to a task card — and the whole thing fell over into the browser's bare error screen. A reload always fixed it and the server logs were spotless, which is the worst pair of symptoms to chase: nothing to read, and it stops happening the moment you go looking. Two parts of the app were caching the same request under the same name while disagreeing about the shape of the answer, so whichever one asked first decided what everybody read back for the rest of that visit, and the half expecting a plain list got handed a box with the list inside it. Every endpoint that had drifted apart that way now has one name and one shape, and a test refuses to let a second one appear. Two more live crashes went with it: the repositories panel on a card, and the board picker in a calendar event.

A databank is somewhere you browse: you open a bundle to check whether it is the one you meant, then the next, then the one two tiles over. Each of those either threw a dialog over the grid you were working through or took you off the page entirely, and both cost you your scroll position and whatever you had selected. On a wide screen the previewer opens as a pane docked to the right instead — no overlay, no scroll lock, the grid keeps its place and its selection — and you can drag the pane's edge or arrow the divider to whatever width suits, which it remembers for next time. ←/→ still steps through the sheet in the order you are reading it, grid or list. A picture arrives as a panel rather than a lightbox, with a way out to the full-screen version when a wide table outgrows the pane; on a phone, where there is no room for a second column, it stays the full-width sheet it was.

A team became two colours and an uploaded picture, but only the surfaces where the team is the subject learned it — the navbar badge, the team header, the ring around your avatar. Everywhere a team merely owns something it was still a word in a tint: a search result's chip, the board switcher's generic people icon, the workspace named in the board's bottom bar. At ten pixels, two teams a shade apart are the same chip until you stop and read the word, which is the opposite of what a face is for. All of those draw the same tile now, and which shape it takes follows one rule: a row that owns something keeps a small mark beside the name, and a row that is the team leads with a bigger one and drops the chip, because the chip would only repeat its own title. The switcher, the workspace heading and the bar two controls away finally agree about what your workspace looks like.

A canvas with fifty-odd images on it was fine on a laptop and close to unusable on a phone. Two reasons, both fixed. The board kept a fixed margin of mounted embeds around whatever you were looking at, which on a 375-pixel screen meant building nearly four times the visible area — it is a proportion of your viewport now, so a phone and a monitor carry about the same surplus. And the small end of the zoom range was still drawing full-resolution originals: a one-megabyte sprite sheet unpacks into four megabytes of pixels, and an animated gif re-draws every frame for as long as it is on screen. Zoomed out you get a 640-pixel still — a gif shows its first frame — and the original, animation and all, comes back as you zoom in. The list of your boards also stops building the desktop rail and the phone sheet at once; you get the one your screen is wide enough for.

The app knew about attention in three unconnected places: the launcher rail scored blocked and due cards, the timeline dock read companion flags, the calendar tracked runs that ended blocked — and none of them agreed, none read the others' signals, and neither the dashboard nor a team page mentioned any of it. There is one engine now, and a navbar slot for it. /attention lists every card that is blocked, overdue, due within the week, assigned to you, or carrying a companion flag no human has answered — one row per card, every reason it trips as its own badge, ranked so a blocked-and-overdue card outranks a merely blocked one. An unanswered flag is exactly that: an attention comment with no human reply after it, so a companion following up on its own thread doesn't clear the alarm, and your one-line answer does. Beside the list sits the rest of what waits on a human: your agent sessions that ended in error, teammates' requests on sessions you own, join requests for teams you manage, scheduled runs that stopped, and your unread notifications. The dashboard opens with the same list next to a new feed of what's been happening around you — every action on your teams' boards, sketches, bundles and the rest, plus your own, wearing the same actor line as the audit trail, agents included. Team pages get the pair too, scoped to that team: what needs you here, and the team's latest activity. The panels keep themselves fresh — a companion acting or a notification landing nudges them within seconds.

Columns are what make a board readable and what make it slow to search: a card you half-remember sits behind one horizontal scroll and six vertical ones, and the only order on offer is wherever somebody dragged it. Press v, or flip the switch in the bottom bar, and the same cards arrive as one flat list. Search is a single box taking terms in any order across the title, the TL;DR, the description, tags, column, subtask lines, assignee names and the card id, with a bare #tag aimed at tags alone — accents and capitals ignored. Sort by created, touched, card, column, priority or due; undated cards park at the end whichever way you sort, rather than pretending to be the most urgent thing you own. It is a view, not a second board: the filter bar narrows both, a row click opens the same card, and the row menu is the card menu. The view and the sort stick per board; the search deliberately does not.

The databanks page could only answer which one of these is the one I mean: a grid of cards in alphabetical order, where the container that took twenty files yesterday looks exactly like the one nobody has opened since March. There is a list beside the grid now — one row per databank, sortable by name, scope, how many items it holds, when it was made and when it last saw anything, opening on the most recently active. That last column is the point, and it needed care: a databank's own timestamp only moves when someone edits its title or description, so filing a hundred files into it never touched the date, and sorting by it would have ranked your containers by who last renamed one. What you sort by now is the newest thing that actually happened inside. The grid is untouched and still alphabetical; the toggle and your sort are remembered per browser.

The timeline could split the whole feed into people and agents, but not answer the question a feed of humans-with-companions invites: what did Ada and her agents do this week? Every event already knows the human behind it — a companion acting over MCP is recorded against the person whose account it ran under — so someone and their companions share one identity, and picking a person is a second dial rather than a rival filter. Choose one and the people/agents chips relabel themselves to both, themselves, or their companions, so two controls stop both claiming to filter who. The picker lists only people who actually did something in the window you are looking at, and each name carries its own split: their own actions, then their companions' behind a small bot mark. Every count tells you what clicking it would show.

An agent could make a card, move it between columns, nest it, archive it and comment on it — but a card filed on the wrong board stayed there. The only way out was to copy the fields into a fresh card on the right board and delete the old one, which throws away the comments, the attachments and the id anyone had already linked to. There is a tool for it now: name the card and the board it belongs on, optionally the column it should land in, and it changes boards with everything hanging off it intact. Every place that keeps its own copy of which board a card belongs to travels with it — including the record of what agents got stuck on, which nothing shows you until somebody opens it, and which would therefore have been the last thing anyone noticed pointing at the old board.

Our own agents work in Claude, and so do most of the people using this. When Claude publishes an artifact — a report, a review page, a small app — the only way to keep it here was to paste the link into a description, where nothing could find it again, nothing said what it was, and nobody could tell whether the link would even open for them. An artifact is a thing now. You file it once, with a name, and it becomes a card in a databank and a row on a task, filed by you or by the agent that published it, with the companion's own name on the line. Two things it says out loud that a pasted url never did: when a link is a public share it says so, and an artifact can carry a stored copy of the page itself — the html the agent published, filed as a databank file. Where there's a copy, the card stops leaving the app: the page renders in the previewer inside the sandbox every uploaded page here already runs in, you can pin review comments into it, and it keeps working the day the link doesn't. Agents get the same two halves over MCP, one call to file an artifact onto the card it came out of, another to bind the html they just published.

Importing 523 rows of 66 fields through an agent cost roughly 1.2 million tokens, and every row crossed the wire three times: read out of the source file, written into the tool call, then handed straight back in the reply. The third pass buys nothing — the caller already has the rows. The only facts it does not have are the new ids and which rows failed, so a bulk insert can now ask for exactly those and nothing else. Failures are never trimmed, in either shape: a row that did not land is the one thing you cannot reconstruct from what you sent, and a compact reply that hid them would be quiet data loss dressed as a saving. Nothing changes for a caller that does not ask — this is opt-in, for the one case where it actually hurts.

Pressing ? on a canvas opened the underlying drawing library's own help dialog, and it was wrong for us in two directions. Every link in it pointed at another product — its docs, its blog, its issue tracker — so anyone asking a question about this editor got sent somewhere that has never heard of it. And it described only the drawing half: restore points, following someone, presence, chat, marks, embeds, locked versus editable and what the save indicator means appear nowhere in it, and that half has grown every release. ? opens ours now, and it carries both halves on one sheet. The drawing shortcuts printed on it were read out of the library rather than remembered, and a test holds them to it — so the day an upgrade moves a letter, the test fails instead of the sheet quietly describing a key the canvas stopped having.

The switcher was the only way to move between boards, so it listed every board the account could reach — personal, then a coloured section per team, then shared. That list grows with the account, and in the middle of a board it answered a question nobody asks: which of my seventeen boards, across five teams? It reads top to bottom as three answers now. Across all boards leads, because the task log and the timeline don't depend on picking a board at all. Then this workspace's boards, through the same lens every other list uses — the team you're in, or your personal ones, plus the shared ones that belong to every workspace. Then search all boards, which opens the launcher already narrowed to boards, so a board in another workspace is a keystroke away rather than unreachable. The board you have open is always listed even when the lens would drop it: a menu that doesn't contain the board its own trigger is naming reads as broken.

A databank paid for its own tagging. The filter was a cloud of every tag in the container sitting above the content — a hundred and twelve of them on one databank, four hundred pixels of chrome before the first file, and a strip that shifted under your cursor every time the tag list changed. The controls fold into one bottom toolbar now, the twin of the taskboard's: a search box over name, file name and tags, the sort, the view switch, how many of how many, and Clear — with the tags behind a single chip that grows its own filter box past twelve and sorts the active ones to the top. The page keeps its own scroller, so the toolbar stays put on a databank 261 cards long. Tiles fill the width instead of running three abreast down the middle of a wide monitor, and a third layout lays every file out flat across folders, 48 to a page, labelled as a range so you can tell whether you are looking at everything.

A recipe had a page of its own, which answered what does this one say — but nothing answered the question that comes first: what do we have, and which of it is live? Workflows were reachable from the console rail, a databank card, or somebody's pasted link, and nowhere else. There is an index now. It lists every workflow you can see, your own plus every team you are in, with a search box, chips for workspace, status, source and trigger tag, and six ways to sort. The search reads the steps too, because half of what you remember about a recipe is a phrase one of its steps used. It deliberately does not narrow to the workspace you have selected — a recipe is looked for by what it does, and which workspace it lives in is the answer rather than the question — but a single recipe's page now rebases onto this list when you switch workspace, instead of dropping you on a dashboard.

A Google calendar that stopped syncing told you to re-grant calendar access in Settings — while being displayed in Settings, beside a row that only shows the re-grant button when the stored permission is already missing. The one state that sentence was written for was the one state where its button could not appear, and every other refusal was collapsed into the same wording whether re-granting would fix it or not. The row repeats what Google actually said now: a permission the grant no longer carries, an interface the project never switched on, or too many requests, each named plainly and none of them pointing back at Settings. A refusal that proves the permission is gone strips it from the account, so the row offers to grant it again and the background sweep stops hammering an account Google is turning away. Every failed row grows a re-grant button, and the row menu gained Remove calendar — it forgets the mirror and the stored grant without touching how you sign in.

A team is two colours everywhere it appears: the accent bar under the navbar sweeps both, and so does the rim on the mark's badge. The ring around your own avatar wore only the first of them, so two surfaces an inch apart disagreed about what colour the workspace was for every team that isn't a single flat hue. The ring could not do better while it was a shadow, which can only hold one colour. It is painted behind the avatar now, tucked inside its own edge so nothing around it moves — the unread dot and the focus outline keep the geometry they were tuned against — and switching workspace is still the same 300ms widen-and-recolour rather than a snap. The badge under the mark gets a thinner rim in the same pass: at that size anything fatter reads as a ring with a filling rather than a face with an outline. Both surfaces hold the last team's colours while they fade out, so leaving a team no longer flashes grey.

A card sent to the team train had exactly one place to say where it stood: its own card. Nothing showed the queue, so "am I behind someone?" and "why has this not moved?" had no answer anywhere, and a train that quietly stopped pulling stopped quietly. The team dashboard draws the rail now. Engines sit on the left — one per agent shared into the team, each reading FREE or PULLING, smoke off the chimney while a run is going, and the card it is hauling named underneath. The queued cards follow as cars in the order they will be taken, each with its position, its board, how long it has waited, who queued it, and whether it is next out, waiting, blocked or stuck. The reason a car gives is the runner's own verdict from the same sweep the watcher runs, not a second opinion that could disagree with it. A card on a board you cannot see stays in line as an unlabelled car so the positions around it stay honest.

Changing workspace changed what the app was about but left you where you were: pick another team while reading a board and the navbar said the new team while the page underneath still showed the one you had just left. Only three kinds of route ever followed the switch. Every route follows now. A team sub-page rebases onto the team you picked, so a calendar stays a calendar; a section that is a lens on the workspace returns to its own entry point and re-resolves there; a page that means the same thing in both places leaves you exactly where you are; and anything else lands on the new workspace's overview — the team's dashboard, or your personal home. Two screens deliberately do not move: an OAuth consent and an invitation you are part-way through accepting are mid-transaction, and navigating away would abandon them without saying so.

Six icons in the navbar, and two of them were readings of the same cards a third one holds. The task log is every card on one flat sheet; the timeline is everything that happened to those cards on one spine. Neither is somewhere you go instead of the boards, so neither earns a top-level slot beside Sketches, Databanks and Calendar. They hang off the taskboards hub now — the same arrangement memos, knowledge bundles and SimpleTable already have under databanks. The hook is the board switcher, with an "Across all boards" section at the foot of the list, and /taskboards takes you to a real board instead of a landing page. Both routes still work and stay bookmarkable, and both gained a way back: a link above the heading on the task log, and the leftmost slot of the timeline's toolbar. On a 375px phone the timeline's search field comes out wider than it was before the move.

A bowl left you holding nine objects and no account of them: to know what your agent had actually built, you opened each one and worked it out. Every bowl now ends by drawing itself. The agent makes a second sketch — a storyboard of the run — places every object it made on that one canvas (the card, the tables, each saved chart, the subject sketch, the knowledge bundle, both documents), captions each with what it is, why this bowl needed it and what you would do with it next, and joins them with arrows in the order they were built. Open that canvas and you can explain the whole hour without opening anything else. Bowl 2 comes back with maps now, too — the Benelux brief asks for ISO codes and coordinates, so the three countries arrive coloured on a world plate and every enclave, tripoint and low point sits where it actually is. And bowl 3, the one written from your own sentence, decides for itself: if your subject has places in it, the model says so and the recipe asks for the location column and the map to go with it.

A column of country names is a map waiting to happen, and until now the chart view could only make it a bar chart. Three map shapes join the picker. A region map colours in an atlas: type Netherlands, NL, NLD or 528 and it finds the same country, and US states answer to their name, their postal code or their FIPS number — on a plate that is always Albers USA, because that is what a map of the States looks like. A bubble map puts a circle at every location, sized by whatever you are measuring. A shape map draws the table's own outlines — a delivery zone, a floor plan — and will stand them on a world map or on nothing at all. The world can be flattened five ways, and you pick between them by looking: the projection control is a gallery of the same globe drawn each way, including one that stays a globe and turns to face your data. Every map counts what it could not place and says so under the picture — and if your values are US states sitting on a world map, it offers you the plate that would have recognised them.

A location column holds a point on the globe. Write it however you have it — { lat, lng }, latitude and longitude, or just "52.3676, 4.9041" — and the column stores one canonical pair and shows it pinned. (A bare two-number array is the one thing it refuses: half the world writes those latitude-first and half longitude-first, and a coordinate silently mirrored across the planet is worse than one that fails.) A geojson column holds an actual shape — a point, a route, an outline, a whole feature collection — as an object or as its JSON text, checked coordinate by coordinate on the way in, with an unclosed ring quietly closed for you. In the grid a shape shows as its own small silhouette next to what it is, so a column of them reads at a glance. Both are what the new maps plot, and both are available to your agent through the same tools it already uses to build a table.

Two more shapes in the chart picker. A treemap answers the same question a donut does — what are the parts of this whole — but spends area instead of angle, so it stays readable at thirty categories where a ring gives up at ten, and each rectangle carries its own name. A heatmap crosses two of your columns into a grid and shades every cell by the number, which is the picture for questions with two dimensions and no obvious axis: revenue by region and by segment, tickets by weekday and by team. Both follow the rules the other shapes already do — the pickers only offer fields that mean something, and both render into the same preview image a databank card or a sketch embed shows.

Zooming out on a canvas full of embeds erased the very thing you zoomed out to see. Past about 90% every tile dropped to a title and a line of meta, and below a certain size it fell straight to a bare glyph — so a thirty-tile storyboard became a field of six identical icons, which tells you what kinds of thing are on the canvas and never which ones. Two separate limits were doing that, and both were tuned for looking at a single embed rather than a wall of them. Tiles now keep their full detail down to 62%, and a small tile steps down one rung at a time to whatever actually fits instead of falling off a cliff. In between there's a size a board is genuinely read at: the picture alone, edge to edge, with the title floated over it. Anything with no picture gets its own glyph blown up and dimmed behind the title rather than a blank.

Renaming a taskboard was the one board operation an agent had no way to reach. It could create a board, move it to a team and delete one, but not retitle it — the rename existed only in the web dialog. That gap is worse than a missing convenience, because the obvious workaround is destructive: the shortest visible path from a board called one thing to a board called another was to delete it and make a new one, taking every column, card, comment and link along with it. There's a rename now, and it says exactly that in its own description, so the ruinous path never looks like the cheap one. It turned up by being hit: a cleanup pass filed fifteen cards onto a team board named Backlog, which then collided with the hand-ranked backlog on /tasklog, and nothing could fix the name. The new title lands live for everyone watching the board.

Bar, line, area and scatter answer a lot, but not everything, so four shapes join them. A horizontal bar is the ranking, with long category names still readable. A grouped bar sets series side by side off one baseline, comparable to each other in a way a stack never is. A hundred-percent stack shows the mix and deliberately takes the total away. A donut is part-to-whole for one field: it takes no split and always sums, because a ring of averages divides nothing, and it folds its tail into a single slice as soon as it would run out of distinct colours — two slices sharing one is a ring you can't read. Each shape now carries its own rules about which fields can hold an axis and whether a split is optional, required or meaningless, so you're only ever offered something that plots. And the shape picker is one row again, instead of stacking the name underneath its own icon.

A table linked to a card was the one attachment you couldn't open in place, on the theory that a table has no picture to show — which confuses a picture with a preview. Four tables called Bodies, Sky events, Trajectory samples and Spacecraft are told apart by what is in them, never by the same icon four times. Click one now and it opens in the previewer as its data: the first eight rows and six columns, formatted the way the full grid formats them, and it says plainly whenever it has cut something off. The whole table is one click behind that. A card linking four tables still costs nothing until you open one, and on a phone the preview scrolls sideways inside its own box rather than dragging the dialog with it. The arrows step through it in the same order as everything else on the card.

A chart you saved was a link on a card and little else: opening it left the page, and the previewer's arrows stepped straight past it. It takes a slot in that ring now, so a chart previews beside the card's files and bundles without going anywhere. You can also put one on a canvas — the picker searches your charts by name and names the workspace each one belongs to, since "Distance from the Sun" means nothing on its own and is unmistakable next to "Solar System". Underneath all of it was a bug that would have made every one of these draw nothing: a chart's preview image was never a document a browser could open by itself, missing the one declaration that makes it valid, so it failed silently — a broken glyph, no error anywhere, the request itself perfectly fine. Fixing that repaired the canvas tiles and databank cards that already existed, not just the new places.

A year of monthly samples charted as a line came out completely empty — no error, just nothing. Three things compounded. The buckets were chosen from the length of the window rather than how often the data actually arrives, so twelve months became fifty-three weekly bins holding thirteen readings; the empty bins in between read as gaps, and a line draws segments between points, so every real reading sat stranded with nothing to connect to. Buckets now follow the data's own cadence, and quarters and years join days, weeks and months so a long span has somewhere sensible to land. Counts and sums keep the finer bucket, because there an empty week really is a zero. Point markers switch on whenever a reading is stranded, so a value with no neighbours is still visible. And the colour scale carries twelve distinct hues instead of five, so ten series no longer come out in the same violet.

Scrolling to the end of the home page on an iPhone flashed a white band above and below the footer as Safari's bottom toolbar slid in and out. The footer was never the culprit. The dark surface you see is painted on the page's own content, while the backdrop behind the whole document comes from the theme — which, on a phone set to light mode, resolves to very nearly white. Safari shows you that backdrop in exactly two places: the rubber-band gutter past the end of the page, and the strip it exposes while the toolbar animates. The page ends precisely at the bottom of the document, so there was not one dark pixel held in reserve, which is also why it only happened during the animation. The page now declares its backdrop as ink whenever an ink surface is on screen, with no script involved, so it's right from the first frame. Both themes; the login page is untouched.

Installing the MCP server leaves you with a connected agent and nothing to point it at, and a demo of our data proves nothing about yours. /dogfood is a brief you hand to your own agent instead. There are three: the solar system over the coming twelve months, the Benelux and the comparisons that overturn an assumption, and — from one sentence about what you actually work on — a third written around your own subject. Each asks for the same nine objects, so what you get back is a board, typed tables with real rows, a chart, a sketch, a knowledge bundle and a deck sitting in your account, made by your agent rather than described in a video. Copy the recipe or open it straight in Claude; the page is public, so you can read all three before you have an account.

Dragging anything that wasn't an image onto a sketch produced a full-screen "Couldn't load invalid file" dialog — the canvas could only ever accept images and scene files, and said so in the rudest way available. Drop a video, a PDF or a spreadsheet on it now and the canvas takes the drop before that dialog can happen: the file uploads into the sketch's team databank, or your personal one, under a Sketch files folder, and lands as an embed at the exact spot you dropped it, with a progress ghost holding that spot while it uploads. A plain image still becomes a real drawing element you can crop and rotate. A placed video shows its first frame with a play badge instead of a grey placard. And on a locked canvas you get "unlock the sketch to add files to it" rather than an error about a file that was perfectly fine.

A table answers what is in here; it never answers what shape is this. There's a chart view beside the grid now — pick a shape, an x, a y and a split, and the whole configuration rides in the address, so a link reproduces exactly the picture you were looking at. Field types drive the pickers, so you're only offered axes that mean something: dates and selects bucket, numbers reduce, and free text stays out because every bar would be a bar of one. It plots the whole filtered table rather than the page you happen to be on, and the footer says how many rows it drew and how many it skipped. Save one and it becomes an object in its own right: a live chart re-reads its table every time you open it, a snapshot freezes the rows it captured and tells you which version of the table that was.

Which workspace you were in was a 2px accent line along the bottom of the navbar — enough to notice that something changed, not enough to answer "which team am I in" without opening the account menu. In team context the team's own face now hangs under the heart in the top left. The mark rises 7px to make room, which is exactly the distance its idle drift already travels, so entering a team reads as the heart lifting rather than as the lockup jumping to a second layout. The tile is a circle rather than the rounded square teams wear everywhere else, because at that size corners read as a rendering fault against the mark's curves, and it wears a thin rim in the team's own two colours that turns once every 22 seconds — stopped, like everything else here, when you've asked for less motion. Personal context looks precisely as it did.

Video goes on a card and into a databank now, the same way an image does — drag it in, and it plays wherever files already preview: the object previewer, the standalone viewer pages, databank grid and list cards, sketch embeds and chat chips, all from one player. Only containers a browser can genuinely play are accepted, so nothing gets stored that turns into a broken frame later, and video carries its own 200 MB ceiling rather than sharing the image one. The proxy streams in ranges instead of handing over the whole file, which is what makes the scrubber work at all and what iOS Safari insists on before it will play anything. On a card a video shows a first-frame tile beside your images, and it never competes for the card's cover — a cover is a picture you chose, not the first frame of a screen recording.

Tags hand a card to an agent whenever one comes along, and a scheduled pickup hands it over at a time you named. Neither answers the ordinary request: somebody pick this up as soon as somebody can. A team train does. Put a card on your team's train and it waits in line; the first shared agent that is actually free — one whose owner has a Claude account, no run already going, and permission to see both the board and the card's repo — takes the head of the queue and starts the same way any other pickup starts, so two agents can never end up doing the same card. A card that gets claimed, archived, nested or finished leaves the queue on its own, and a blocked card keeps its place instead of jamming everything behind it. You can queue from the card, from /train, or let an agent do it.

The model and effort a card carries could only be set by hand in the web app, so an agent sorting through a queue could hand work off but never say how hard to think about it. update_task sets both now: pin the quick fix to haiku, pin the gnarly migration to opus on max, or clear either back to the default — and whichever agent picks the card up, by tag, by train or by schedule, runs with the card's choice ahead of its own profile setting. The values it accepts come from the same definition the web form reads, so the two cannot drift into disagreeing about what a valid model is, and passing something that isn't one comes back naming every option rather than a bare rejection.

schedule_task_pickup has documented a recurrence since the day it shipped, and no agent could ever send one. The parameter's shape didn't survive the trip into a client's tool catalogue — it arrived there as an untyped blank, the client sent text where an object belonged, and the server rejected the call against the very schema its own description advertised. So every repeating pickup had to be made by hand in the web app, and over MCP the tool was quietly one-off only without ever saying why. Booking every weekday at nine from an agent works now. A test walks every published tool's parameters and fails on any object hiding in that same shape, naming the tool and the parameter, so the next tool to ship cannot lay the trap again.

A board tells you where a card sits in its own process. Once there are a dozen boards, nobody can answer the question people actually turn up with — what have we got, and which of it are we doing — because the answer is spread across boards and columns ordered by a drag somebody made weeks ago. /tasklog is every card you can see on one flat sheet, most recently touched first, with board and column demoted from containers to columns you sort by. Search matches title, description, board, lane, tags and the tsk_ id, so pasting an id an agent handed you lands on the row, and a #term matches tags alone. Beside it sits the backlog, the ranked shortlist no column can express: one bookmark puts a card on it and dragging re-ranks it. Which backlog a card joins follows from its board, so a personal card can never surface on a team's list.

Everything auto-agent on a card lived as a loose stack of sidebar sections — Repository, Workflow, a pickup banner, Scheduled pickup — each explaining itself at full length whether you cared or not. They're one widget now, collapsed by default to a single line that reads like a sentence: the repo an agent would clone, the workflow it would follow, when it picks the card up. Expand it and the full controls are all there, including something the stack never had: a Model and Effort choice for this card. A quick fix can say haiku and be done cheaply; the gnarly migration says opus on max — and whichever agent picks the card up, by tag or by schedule, runs with the card's choice over its own profile default, each half resolving independently so pinning one keeps the agent's other. A green pulse in the widget header means a session is on it right now, and a warning mark means a scheduled run needs you — visible without expanding anything. The expand choice is yours once, remembered across every card.

A team's identity was one colour rendered as a 10px circle, in a dozen places that all looked identical to each other — you could see that a team was selected, not which one, without reading the name beside it. Teams now carry a real appearance: a two-stop gradient (twelve curated presets, or mix your own, or stay flat — solid is an explicit choice, not a gradient with equal stops) and an optional uploaded avatar, exactly like a profile picture. They wear it everywhere the dot used to be: the team overview header, the admin list and detail, the account dropdown and switcher, your personal team cards, the chat sidebar and the invite page — as rounded squares, so shape alone tells a team from a person. Initials pick whichever ink actually contrasts against the middle of the gradient where the letters sit, so the light presets don't hand you white-on-lime; below 20px the tile drops them rather than render smudges. Everything that legitimately needs one flat colour — card scope dots, calendar chips, the notification rail, the mobile app — keeps reading the first stop, unchanged.

Showing what you mean on a card meant attaching the screenshot to the sidebar and then writing a comment that pointed at it — "see the second attachment" — with the picture nowhere near the sentence it belonged to. Paste an image into the comment box now (⌘⇧⌃4 and paste, drop it on the box, or use the image button) and it does both: the file lands under Attached like any other upload, and the comment itself carries the image inline, rendered where you put it, in both the simple and classic thread views. Click it to open the same viewer the rest of the app uses, arrowing through every image in that comment. Agents can do it too — upload_task_file hands back the attachment id, and add_task_comment embeds it with , so a companion can show you the failing screen beside the sentence describing it instead of asking you to go find the file.

If a call is already being transcribed, the place to read it is the panel everyone is already in. Every finished spoken line now also lands in the call's chat as a message from whoever said it, interleaved by time with what people typed — so the person who joined late scrolls back through one thread instead of two, and the thing someone said while you were muted is quotable. Spoken lines are drawn outlined and with a captions mark, as plain text: it's a machine's guess at speech, where an "@" is a word and not a mention. It's on by default whenever transcription is on, and off is a per-browser choice reachable from the controls pill, the More sheet and the K menu. Nothing extra crosses the wire — every client already holds every segment, so the weave happens locally and no relay can double-post. The durable copy is unchanged: the full transcript is still filed to the databank and linked into the conversation when the call ends.

Reviewing an html deliverable meant reading it through a letterbox: the top third of the page went to things you read once — the card, the file name, a metadata line, a six-button row that wrapped to three on a phone — and the document got a fixed box below all that, whose own scroller ran past the fold. Two stacked scrollbars, and the document was the part that got squeezed. Now the file is the page: it takes every pixel that isn't chrome, the page itself never scrolls, and the only scroll left is the document's own. The chrome is one 44px row along the bottom in thumb reach — the card's short id, Review, Notes, Fit and ⋯ — with the card, the file's details and Download behind that id, and Focus and Present under ⋯. Two fixes came with it: a refresh no longer lands you in "selection unavailable" (the page and the annotator used to race on load, and whoever won decided whether review worked — now the viewer asks until it gets an answer, so it arms every time), and a tap that used to vanish silently now lands. A slow tap, a tap on the empty gutter beside a centred document, or a hold that selected text all pin or quote instead of being discarded, and anything genuinely unpickable says so rather than doing nothing.

The card board answers "how is this databank organized" — which is the wrong tool for the question people actually arrive with: "when did I put that thing in here, and what was it called?" So there's a second view now, on a toggle beside the sort menu and remembered per databank. It's flat: folders stop being containers and become a column, so a file filed three folders deep is one glance away instead of one expand away, and the columns carry the facts a file has — kind, size, added, last touched — each sortable in both directions. It opens on most-recently-touched first, which is what you came for. Clicking a row opens the same previewer the rest of the app uses, walking the sheet in exactly the order it reads, and modifier-click still selects, so the bulk bar works the same in both views. A long file name can't push the sheet sideways — a list view that scrolls horizontally isn't one.

Agents write `inspection/report-2026-08-15.html` the way anyone writes a path, expecting the first segment to group the file. It used to be stored verbatim: a root-level item whose visible name was the whole string, slash and all — no folder, no grouping, and a card that reads like a bug. Now that path means what it looks like. `folder/file.ext` finds or creates that root folder and stores the bare name inside it, identically whether the upload came from an agent's inline call, an out-of-band ticket, or the browser's own form. Folders are one level deep, so a deeper path is refused with the name to use instead rather than quietly flattened into a layout nobody asked for, the check happens before the bytes move, and a rejected upload leaves nothing behind — no orphan folder, no orphan file. The upload receipt now reports where the file actually landed instead of echoing the path it was handed.

When the platform checked a connector's token, anything that went wrong on the way to the database — a cold pool, an exhausted connection limit, a failover — came back to the client as 401 invalid_token. That is the worst possible thing to say, because a 401 has exactly one correct response: drop the connection and sign in again. So a blip that a single retry would have absorbed instead tore down a working agent session, and it did it invisibly, since a spurious 401 is indistinguishable from an ordinary bad token in the logs. Token lookups now retry once and, if the datastore is still unreachable, answer 503 with Retry-After and no re-authentication challenge: try again, don't throw your credentials away. Every outage is logged under one tag, so the next one is greppable instead of silent. A genuinely bad token still gets its 401.

One runner serves every session, so /tmp was shared between them — and because the spawn environment was built clean, everything that asks the system for a temp directory resolved to that one shared place. Two concurrent sessions doing similar work pick the same obvious file name, and the second silently overwrites the first: seen in the wild as a session's downloaded page coming back full of another site's links, mid-measurement. No error, just wrong numbers in a report. Each session now gets its own scratch directory inside its workspace — a sibling of the checkout, so nothing written there can reach a diff or a commit — with the environment pointed at it, on the container path too. And since an environment variable only fixes tools that ask, every agent is now also told, on every turn, where its scratch directory is, that /tmp is shared, and what goes wrong if it hardcodes one.

A sketch used to be findable only by its title, which is the one part of a canvas nobody maintains. Now the words written on the canvas are searched too: the text of every sketch is indexed alongside its title, kept fresh on the same cadence its versions are captured (plus renames, copies and new sketches), so "evaluate repo" finds the board whose canvas says it while its title never did. Typos are covered by the fuzzy name arm and meaning by the semantic one, fused into a single ranking — the same engine omnisearch and ⌘K already use, so this works everywhere, not just in the sketch picker. The picker itself became a two-pane dialog on a desktop: whatever the highlight is on — hover or ↑/↓ alike — renders live beside the list. Real bodies, not placards: the sketch's own SVG, the card, a bundle's concepts, a file's text, the image. The top hit previews by default, so the rail always answers the query you just typed.

The app had grown three parallel previewers — an image lightbox, a file viewer, and a per-canvas record dialog — each with its own left/right ring, so arrowing off an .html pinned to a sketch skipped the knowledge bundle sitting right beside it, and a sketch placed on a sketch previewed as nothing at all. There's one previewer now, over a mixed list: images keep their full-bleed stage, everything textual gets the reading pane, and a sketch shows its rendered canvas with a way out to the real thing. A sketch's embeds and a card's Attached area each build a single ring in the order you see them, so ←/→ walks exactly what's on screen; chat, calls and the databank grid all ride it too. The picker rail stopped resizing under the pointer — the dialog is a fixed height, so moving the highlight from a long transcript to a short item no longer slides the list out from under you — and the four kinds that had nothing to show (workflows, repositories, folders and SimpleTable bases) render real summaries instead of an apology, which took the sketch canvas from seven of its ten embed kinds previewable to all ten.

A card asking for a CV was being handed pnpm, docker compose, four verify gates and a database URL. It linked no repository at all — the pickup fell back to the agent profile's default repo, and any repo whatsoever flipped the briefing into its code-work shape. So repo resolution now reads one thing: the card's own link. A card that links no repository gets no clone, no work branch and no environment seed, and its briefing is about the work it actually describes. (A first pass had already softened the inherited case, pointing at the harness instead of dumping it; this removes the guess entirely.) The other half: a clone that can't happen no longer kills the session. A deleted repo row, a missing GitHub connection, a token that won't unseal, a 403 from a fine-grained key — the agent starts anyway, because one that can still read the card, deliver the platform half and say plainly what's broken beats one that dies before its first turn. It's told the truth about what's on disk (nothing, or an earlier run's checkout that may hold its own commits), told not to retry the clone, and asked to report the blocker as a comment on the card. The next activation tries again, so a transient failure heals itself.

The sketch board you share into a call was a plain canvas: everything the page editor could pin onto it — a file, a card, a bundle, a table — was unavailable exactly where a group of people is looking at it together. It now has the same asset picker, the same embeds, and the same live nudge when someone adds one, plus the History control, so the undo list is reachable mid-call and a restore converges live for every participant. Underneath, version history stopped being a partial record: every write to a canvas now leaves one. Hand edits snapshot the scene as it was before an editing burst (once per burst, not once per keystroke), agent, assistant and restore writes capture unconditionally, and each entry says who displaced the state — so "put it back the way it was before that" is answerable no matter who or what changed it.

Attaching a file that already lived in a databank meant reading its bytes out and uploading them again: two copies of one file, drifting apart from the moment either side changed, and no way for a reader to tell which one the card was showing. A card can now point at the file instead. Nothing is copied — the bytes stay in the container — and everything downstream treats it exactly like an upload: it lists among the card's attachments, opens in the viewer, renders through the same sandboxed route, and an .html file is reviewable with notes pinned into it. Two things differ, both deliberate. Access follows the container, per viewer, on every read, so pointing a card at a team's file can never widen that file's audience — a teammate who can't open the databank doesn't see the row at all — and attaching a narrower file to a wider board still works, but the receipt tells you who won't see it instead of leaving you to assume you'd shared it. And removing the reference takes the pointer only: the row wears an unlink, names its container, and the databank's bytes stay exactly where they were. It's in the card's Add menu, and agents have it over MCP.

Review mode was mouse-only, on the one device with no mouse: tapping an element drew the hover box and then stopped, because mobile Safari never sends the click the picker was waiting for. Picking now commits on the lift of a finger — a pointer that came back up near where it went down — which leaves scrolling and the press-and-hold that starts a text selection alone, and a selection raises its own "Comment on selection" button, parked clear of iOS's own copy callout. Three more phone-shaped bugs went with it: pins that sat off the side of the screen for a deck authored at laptop width are now clamped into view and follow the scroll, the picking hint moved off the deck's title and takes a dismiss, and Present — which iOS won't give an embedded document — is replaced by Focus, an in-app immersive view that takes the deck from 583 to 766 pixels of an 812-pixel screen without reloading it. The notes rail no longer squeezes the file it's about: below a laptop width the notes ride a bottom sheet, raised by the pick that produced them and dismissed when you're done, so the document keeps the full width. And Fit scales a laptop-width deck into the screen while keeping its pins and buttons fingertip-sized, for when you need the overview.

A link straight to an attachment — a URL someone shared, the previewer's "Review", a review pin in a comment — used to land on a page holding a file name and nothing else, with the card it came from one unmarked click away. The card now reads at the top of its file: board and column, the title, its TL;DR, and the same chips the board face carries — blocked, priority, due, tags, comment count, how many files, who's on it — plus a way into the card itself. What you copy off that page is the shareable card URL, not the internal ids the route resolved. Two things got fixed underneath: those chips had been rewritten five times across the board face, the subtask hover, the sketch canvas, the timeline deck and this new page, with real drift between the copies, and are now one set composed into each surface; and "overdue" is judged by your browser rather than the server, so a card due today stopped reading as overdue to everyone in a timezone east of it. Also: "Review" and "Full page" in the previewer now actually go there instead of dropping you back on the board with nothing open — and closing a preview no longer takes the card underneath it down as well.

Two ways a pinned item behaved as though the canvas underneath it weren't there. Scrolling died over an embed: the pinned layer sits beside the drawing canvas rather than inside it, so a wheel or a pinch that happened to start on a card was simply lost. A wheel is now handed straight back to the canvas, so trackpad feel and zoom clamping stay the canvas's own behaviour rather than a second copy of it, and drags and pinches are converted into the pan and zoom they would have produced — a two-finger pinch that used to measure 1.33x when it should have been 2x now lands exactly, with the point under your fingers staying put. On a locked canvas any drag pans; unlocked, a left drag still moves the embed and the middle button pans. Second: the canvas used to answer "where is my content?" as if the board were empty, because embeds aren't drawings. So "scroll back to content" appeared the moment the drawings left the screen while embeds filled it — and scrolled away from them — zoom-to-fit cropped them, and a sketch made only of embeds opened looking at the empty space beside them. Each embed now occupies its own space in that reckoning, without becoming something you can select, drag or export.

A sketch opens locked, which makes it a reading surface — and an embedded image, brief or deck was the one thing on it you couldn't read. A click selected it invisibly, and the only way in was a double-click that navigated away from the board you were reading it on. Now a locked canvas previews in place: images open the image stage, documents open the reading pane, html opens through the same sandboxed route as everywhere else, and the whole canvas is one gallery, so ←/→ steps between them. Markdown and text tiles stopped showing a grey "MD · 362 B" badge where the words should be — zoom in past about 90% and the document typesets itself into the tile, cut on a line boundary (and closing a code fence the cut left open, so the rest doesn't render as one grey block). Tasks and knowledge bundles, the two kinds with something to say and nowhere to say it, open in a reader of their own: the card's chips, TL;DR, description and subtasks, or the bundle's concept index, with "Open card" as the way to everything else. Reading a storyboard shouldn't drag the whole board editor along behind it. Dragging is protected throughout — a press that travels is a pan, not a click, and the modal never appears out from under a gesture.

When an agent attaches an html deck, PoC, or report to a card, telling it what to change used to mean describing the spot in prose — "the second pricing card, the bold line". Open the attachment now and hit Review: the page itself becomes the canvas. Click any element or select any run of text, write the note, and it pins to that exact spot — numbered violet badges in the page, a notes rail beside it, and every note lands on the card's comment thread with a locator the rest of the platform understands (a CSS path, the exact quoted text with context, the element, roughly where on the page). From the thread, "Open pin" jumps you back into the file with that pin focused; resolve and reopen as the feedback gets handled. Agents close the loop over MCP: list_task_review_comments hands them every open note grouped per file with all its locators, they edit the source, upload the revision, and resolve_task_review_comment marks each one done — a whole review round without a human retyping any of it.

Putting something on a sketch used to be a two-step drill-down — pick a databank, then scan its list — and it could only reach things already filed in a container. It's one search box now, the way ⌘K works: type, and it searches every databank you can read plus everything embeddable that may not be filed anywhere yet — cards, sketches, knowledge bundles, tables. An empty query shows what you touched recently, so the landing state is useful. Picking something unfiled files it for you, into the container that matches the sketch's audience (the team's for a team sketch, yours otherwise), which is what makes the embed readable by everyone the sketch is shared with; picking something already there reuses it rather than making a duplicate. HTML files render live on the canvas at close zoom, laid out at desktop width and scaled into their box, inert so the canvas keeps its gestures. Agents got the same reach: a new tool places a card, sketch, bundle or table by its own id — filing it into the right container on the way — so an agent that just created a card can pin it to the storyboard without a human filing it first.

Pin any databank item onto a sketch and see the real thing there — all nine kinds: knowledge bundle, image, file, sketch, card, SimpleTable, repository, workflow, folder. An embed lives in the canvas's own coordinate space, so it pans and scales with the scene, but scaling alone isn't enough: a card at 20% is a grey smudge. So how much of an embed is drawn steps down with the zoom — full preview, then card, then labelled chip, then a bare content-type icon — which turns a zoomed-out sketch into a legible map of what kind of material sits where, and zooming in fills it back in. Embeds aren't scene elements, so they never count against the scene size cap, never ride the autosave, and survive a scene restore. Two independent gates on every path: you must be able to see the sketch and to read the item's databank — edit rights on a shared sketch must never become a way to pull content out of a container you were never given, so a teammate without access doesn't even see the title.

Being in a video call read as "offline" to everyone in team chat. The presence connection belonged to the chat page, so the roster really only ever meant "who has chat open" — walk into the call view and you dropped off it, mid-conversation, exactly when people most wanted to know where you'd gone. It's owned by the app shell now, held jointly by the chat page and the call, with the hand-off lingering long enough that it never blinks offline in between. The sidebar, the thread header and the people rail finally agree on who is here, too — the rail used to be the only one that counted people in a call as online.

Uploading was never idempotent — upload a corrected report under the same file name and the card gets a second attachment — and there was no removal counterpart, so a document that goes through correction rounds stacked versions on the card with no way for a reader to tell which one is current. This came from a real session: six reports, three correction rounds in one day, cards left carrying four files, two of them under the identical name, with a comment saying "use this one, the others are void" as the only signal. delete_task_attachment fixes it, wrapping the same path the web UI's delete button already uses, and delete-then-upload composes into the replace people were asking for — the predictable half, since a "replace" flag would have to guess which of several same-named files it meant. It needs the write scope, not the upload scope: a token allowed to add files must not thereby be allowed to remove them.

Settings → Google accounts now links as many Google accounts as you live across — work, personal, the club you volunteer for — and each one's Google Calendar mirrors read-only into the unified calendar: its own toggleable calendar named after the account, tinted its own color, refreshed on read and swept in the background so deletions and moves over there converge here. Mirrored events open read-only with a jump straight into Google Calendar; your first sign-in account joins in with one "grant calendar access" consent. And because a calendar an agent can't see is a calendar it will double-book, the same unified view ships over MCP: get_calendar_overview returns your real availability (Google mirrors included, freshly synced), create_calendar_event books the slot, delete_calendar_event undoes it — new calendar:read / calendar:write scopes, so a connector only sees your schedule when you say so.

Agent workflows — the named step recipes your auto-agents follow — stopped being a read-only list in the console rail. Every workflow now has its own page: the ordered steps with their done-conditions, the trigger tags that offer it to pickups, its version history, and the enable switch itself (owner or team OWNER/ADMIN — enabling stays a human act, and no agent can flip it). Workflows shelve into databanks like any other artifact, so the procedure sits beside the documents it runs on, and they connect to knowledge bundles — the skills the steps assume — which agents are pointed at before they start. Assignment closes the loop: put a workflow on a card (or set an agent profile's default) and the pickup's kickoff renders the recipe to follow; cards with matching tags offer enabled workflows as candidates the agent may adopt. Agents can also draft and edit workflows over MCP now (create_workflow, update_workflow, plus bundle linking and databank shelving) — drafts only, reviewed and enabled by you.

AI tools increasingly hand you finished HTML — a slide deck, a styled report, a small interactive demo — and until now a databank treated that file as source code: safe, but unreadable. Upload an .html item today (drag it in, paste it in chat, or have an agent store it) and opening it shows the actual page, running in a locked-down sandbox that keeps uploaded markup completely walled off from your session — it can't see your cookies or act on the platform as you. Hit Present to take it fullscreen for an audience, open it in its own tab, or flip to View source when you want the markup after all. Big self-contained decks with embedded images render too — the old size cap only ever applied to inlined text.

The board's quick search had no width of its own, so it sized itself to its widest row: one card with a long title pushed it to 444px inside a 375px screen, hanging 35px off each edge. The start of every row was clipped, and because the dialog floats there was nothing to scroll to reach it — the rows' own truncation could not save them either, since text can only truncate inside something with a boundary. The shared dialog now takes the width the rest of the app already picks, and opens at the top of the screen rather than a third of the way down, where the software keyboard swallowed the list the moment it focused the input. Jump-to-card and "nest as subtask" both mounted it bare and both are fixed; the call menu, which had hand-rolled the same phone rescue for itself, keeps only its desktop offset.

A card lands on the triage deck because a companion asked you something, and the deck used to answer with the first line of the question and a comment count — the one number you can't act on. Now the ask carries the face, name and model of whoever raised it, the thread underneath shows what has happened since (or the run-up, if nothing has), and the footer says plainly whose move it is: waiting on your reply, or who answered and when. Each state carries the button that ends it — unblock, push the due date to today or tomorrow, or type a reply right there. Press r from anywhere on the deck to reply; on a blocked card, "Reply & unblock" closes the whole loop in one press and the card leaves the deck under you.

The floating picture-in-picture was bolted to the bottom-left corner — squarely on top of whatever you were trying to read there. Now grab it anywhere, video or buttons, and drag it where it suits you: a short press is still a tap, so mute, hang up, and return-to-call all work exactly as before, and only a real drag moves the card. It can't be flung off screen, it pulls itself back in when the window shrinks, and it remembers its spot while you hop between pages or in and out of the full-screen call.

The board spent two bordered rows above the columns — the board switcher, scope and team badges, presence, the carousel, search and shortcuts buttons, the board menu, and then the whole filter strip. All of it folds into the same 44px bottom bar the timeline and calendar now use: the columns get that height back, and every control sits in thumb reach on a phone. The filters stay the same chips rather than becoming a parallel mobile UI that can drift — laid inline in the bar on a wide screen, folded into a "Filters" popover with a visible-of-total badge on a narrow one. The shortcuts button hides where there is no keyboard to press, the scope and team badges hide on the smallest screens, and menus that would open into the bottom edge flip upward on their own.

The calendar spent two rows above the grid on chrome: a header carrying the title, the navigation, view tabs, toggles and create buttons, then a row of calendar chips. It now has the timeline's slim bottom bar instead — calendars, then where you are, then how it is drawn, then what you can add, one row on a phone and a desktop alike — and the page goes full-bleed, so the grid gets the whole viewport. The chips became a "Calendars" popover with an "N off" badge, and hiding a team still mutes it in the activity overlay. On a phone the month name shortens, labels go icon-only, and if it still overflows the bar scrolls sideways rather than wrapping into the grid's space. The lightning button's resting height rose app-wide at the same time, so it clears every one of these new toolbars everywhere instead of sitting on top of the timeline's Today button.

Both new views were mouse-only. Each now answers to the keyboard on the board's contract, where one table is both what the listener matches and what "?" prints, so neither can drift into documenting a key it stopped having. On the calendar: h/l or ←/→ step the whole visible period — a month in the month grid, a week in the week view — j/k or ↓/↑ step one row of it, t is today, m and w the views, a activity, f the hour range, n a new event. On the timeline the keys mean a direction in TIME rather than on screen: the spine reads newest-first downwards while the columns run oldest-left, so ← h ↓ j all go back and → l ↑ k all go forward, and each layout scrolls whichever way lands that day. s/c/g pick the three layouts, t is today, a opens the attention deck, m the minimap, o loads older. Stepping walks the days actually drawn, because quiet runs are collapsed — "the day before" is the previous day the page really shows.

Swipe left and the next period comes in, swipe right and the previous one does — a month in the month grid, a week in the week view, exactly what h and l do on a keyboard. The week view pans sideways on a phone, so a flick only pages when the scroller has nothing left to give: scroll across to Sunday, keep flicking, and next week arrives. The month grid has nothing to scroll, so every decisive flick pages it. The gesture is now the app's single definition of a decisive horizontal swipe, shared with the board carousel and the attention deck instead of written a third time.

Seven day columns do not fit in 375px, and both views said so. The month grid gave each day about 50px, so every event chip clipped to a stub like "11:0" with no title left; a day now carries dots instead, one per event in its calendar's colour with a "+N" past four, and tapping the day opens that week — overview then detail, the same split the native app makes. The week view squeezed all seven columns plus the hour gutter into the viewport and reduced every event to an unreadable sliver; the headings, the all-day band and the time grid now share one horizontal scroller with a floor on its width, so you swipe across the week and the headings can never drift out of line with their columns. On a desktop both views render exactly as before.

The week grid was laid out in fixed pixels per hour inside a card sized by the window, so a ten-hour day drew 480px of hours into a 1000px card and left most of the week an unlabelled void with grid lines tiling down into it. The first hour label also lost its top half to the edge of the scroll container. Hours, blocks, labels and the click targets now position as a share of the visible window, so the grid fills whatever height the card gives it and only scrolls once the hours genuinely need more room. The default window is still a working day that GROWS to cover anything outside it — so the compact range can never hide an event — and a new toggle switches it to a flat midnight-to-midnight when you want the whole day.

The timeline now feeds the calendar. Turn Activity on and every day in the month is tinted with the work done on it across all your boards, coloured by team, ramping with volume so three events tint gently and three hundred saturate — and hiding a team's calendar mutes its band here too. Rather than tiling each day as its own flat rectangle, which made the day boundary the loudest line on screen and the share it encoded the least legible thing about it, each day-and-team pair is poured as a soft blob and blurred into its neighbours, so volume reads as mass. Each blob keeps a hot core, or several teams over one week would average into a single flat brown field. Clicking a day opens what happened on it — a pane docked to the right on a desktop, the same content as a sheet on a phone — with real event cards and a link straight into the timeline on that day. The counts are cached per board, per day, per time zone, so a month of heat is one round trip after the first, and a cache outage just means it computes.

Activity mode only ever painted the month grid — the toggle was there in the week view and did nothing. A month is a field, where blobs sit in two axes and can bleed between days; a week is seven tall columns, where the same treatment is just seven vertical smears. So a week day gets a bar instead: height by volume, colour running up through that day's teams by share, with each team's colour pinned at the midpoint of its own band so a day worked by two teams reads as one colour easing into the other rather than two blocks meeting at a line. It spans the whole grid behind the hours and stays put while they scroll over it, and it runs far bolder than the month's wash — a wash sits under numbers and chips and has to stay out of their way, while a bar has nothing on top of it and at that alpha would just read grey.

The event dialog used the browser's own date and time inputs, which ignore the theme entirely — the time one drops an unstyled list that spills straight out of the dialog it belongs to — and accept only the exact digits their segments want. Both are ours now: a themed month grid on the same time-zone-safe maths the calendar views already use, with arrow, Page and Home navigation and explicit Enter or Space to pick; and a typeable time field with a quarter-hour list that opens centred on the current value and shows each option's span from the start time. Typing is forgiving — "9", "930", "0930", "9.30" and "9:30 pm" all land on the same minute — and moving a start time keeps the event's length, with the duration shown as you go. What gets stored is unchanged, so nothing else in the calendar had to move.

A card that got worked on easily leaves eight near-identical rows in a single day — created, moved, two assignees, three edits, a comment. Every one of them is true, and together they bury every other task's day. A "Group" switch in the toolbar folds each task's actions into one card per day, and like the rest of the lens it lives in the URL. It is applied per lane and after the attention split, so something that needs a human can never vanish into a group of routine edits, and a group sits where its newest member sat and keeps its members in order — grouping folds a day, it never reorders one.

A third layout: the loaded range as team-stacked bars, one per day, oldest to newest. It is a rollup of the very same filtered stream the day rows render, so narrowing the projects or typing in the search moves the chart with it. Quiet stretches are zero-filled so the axis stays honest about them, and the bars ride a square-root scale so a three-event day survives beside a three-hundred-event one. Due dates are deliberately left out: a due date is a fact, not an action someone took. A day is a fixed slot, exactly like a column, so history extends leftwards and you scroll into it — which also means Today, day links and the minimap scrubber work here like everywhere else, instead of the chart silently rescaling itself every time older days arrived. Clicking a day opens it on the spine, and a "Read these days" button hands the range to the columns view: same days, same direction, so it reads as zooming in rather than switching tools.

A toggleable overlay along whichever axis the current view scrolls: every day as a tiny bar, length by volume, amber when that day needs a human, quiet runs as dashes — with a window showing where the viewport sits. One surface, two gestures: a press that never travels jumps to the day under your finger, a drag scrubs the range proportionally. It runs vertically beside the spine and the feed, horizontally under the columns view, and the view gives up a gutter while it is open so the overlay never sits on top of the cards. The graph does not get one, since it is already a view of the whole range.

The timeline's needs-attention list gains the board carousel's stage: a full-screen deck flipping through every task that wants a human, across every board, opened from a button beside the focus toggle — in the desktop dock and the mobile sheet both. It is the board deck's contract on purpose: ←/→ and h/l flip, Home and End jump to the ends, Enter opens the card, Esc closes, a decisive swipe flips on touch, edge peeks preview the neighbours, and the tick strip windows around the cursor with chunk jumps, ticking red where a card is blocked. The mode rides in the URL, so Back crosses the boundary out of triage rather than unwinding every card you flipped past, and the overlay itself only loads once you open it.

The attention rail carries a deliberately thin reference to each task — title, blocked, priority, due date — which is right for a list of one-liners and far too thin for a deck whose whole promise is deciding WITHOUT opening the card. Whichever card is on stage now reads the real thing, through the same cache the board uses, with both neighbours prefetched because a deck gets flipped fast. So a card carries the brief itself in plain sentences rather than raw markdown, its priority, due date and tags, assignees or an explicit "Unassigned", comment, attachment and sketch counts, subtasks and how many of them are blocked, git refs with their PR status, the parent it hangs off, its public id and its cover — and whether an agent is already running on it, which is the single most useful thing to know before you act. It stays read-only: changes still happen on the board, one keypress away.

Tagging a card asks an agent to get to it whenever one does. A scheduled pickup names the moment instead: pick the card, pick the agent, pick when — once, or every day, week or month — and it appears on the calendar, because a scheduled pickup IS a calendar point that happens to carry a card rather than a written brief. That means it inherits everything points already have: the run history, "Run now", and the amber attention rail when a run needs a person. It claims the card through the same ledger the tag watcher uses, so a card is never worked by two sessions at once, and a repeat can only fire once the previous claim is released. Every refusal — the card is gone, archived, blocked, already in the last column, or its session is still running — writes a visible blocked run saying which, so the calendar can tell you why Monday did not happen instead of skipping in silence. Set one from the card, or from the calendar's New point dialog.

An agent can now link a knowledge bundle to a repository and unlink it again, drop a repository into a databank, list the auto-agents it is allowed to delegate to, and schedule or cancel a task pickup on the calendar. The listing tool exists because nothing in MCP exposed agents at all, which left the one id a scheduled pickup needs undiscoverable. The count moves from 124 tools to 130 — and the test that pins that number caught the drift on its own, twice, which is exactly what it is for.

Search could find every kind of THING and no people, so "who is Nigel and how do I reach him" had no answer anywhere in the product. It does now, and @ is the one sigil in the grammar: "@mig" narrows to people straight away, while a bare "@" deliberately stays an ordinary query — it is what you have typed halfway through a mention, and hijacking it would make the box feel broken. You see exactly the people you share a team with, never a stranger, one row each rather than one per shared team, and every row carries a face: this workspace has two people called Nigel and two called Miguel, and a name-only row cannot tell them apart. Picking a person is not a navigation, either — there is no destination until the conversation exists — so both the web app and the phone open (or reopen) the direct message and drop you into it.

The week view was seven stacked lists: honest about what was on a day, silent about when. You could not see that two things collide, that a morning is packed or that an afternoon is free — and position is the entire point of a week view. Now the hours run down the left and every timed entry sits at its own start, sized by its own duration, with overlapping entries splitting their column into lanes so a 09:00–10:30 and a 10:00 standup each keep half the width and neither hides. All-day entries stay in a band above the grid, because they have no time of day and placing them in it would be a lie the grid tells convincingly. The geometry is one shared module written in minutes and lanes with no pixels in it, so the web app and the phone cannot disagree about what overlaps what — and the phone gets a week view for the first time: seven narrow columns where you read shape, and tap for the words.

A repository has been a first-class thing here for a while, but what you KNOW about one had nowhere to hang, and a repo was invisible from the databanks hub where every other kind of content is browsed. Two links fix that. A repo card now has a "Documented by" row: connect the knowledge bundles that explain it — a house style, a deploy playbook, one bundle across several repos — with a picker that only loads when you open it, so a settings page full of repos does not fetch the bundle list once per card. This is deliberately not the same field as the default bundle an agent WRITES into; that answers where work goes, this answers what a reader should study. And a repository can now sit inside a databank container beside sketches, cards and tables, so the thing a databank documents lives next to the documentation. It is the one link kind whose destination is outside the app, so it renders as a real external link that says so rather than a route that quietly leaves.

A new page, asking a different question from the board: not what is in play, but what happened. Days flow down a single central spine, and every board you can see — across every team, deliberately ignoring the selected workspace, because the cross-team view is the whole point — is merged into one stream: cards created, moved, edited and archived, comments and status lines, and the days things are due, including the upcoming ones rendered above today. Anything that needs a human runs on its own lane to the LEFT of the spine — attention flags, cards turning blocked, dues gone overdue — against the same day nodes, so routine activity and the things waiting on you never blur together. Every card wears the colour of the team and board it came from. Search, the who and what filters, an attention-only toggle and the project picker all live in the URL, so a narrowed view is a link you can send; quiet stretches collapse into a single slim row; and the range tiles another fortnight into the past as you scroll.

A second desktop layout, one toggle away and remembered in the URL like every other filter: days as COLUMNS running oldest-left, with today anchored toward the right edge and upcoming due days after it. The spine's lane split survives the rotation — the needs-attention band above the day axis, everything else below, with day headings sticky along the top and rotated lane labels down the left edge. Empty days shrink to slim columns and quiet runs collapse to a sliver of vertical text, so a fortnight of nothing costs a centimetre rather than a scroll. The load-older gutter sits at the far left, which is where the past continues. The page also drops its max-width in both orientations: the whole viewport belongs to the time axis.

With 27 projects and 61 things needing attention, the header, the chip strip and the attention rail ate half the viewport before the first day row. All of it is gone from the top. What is permanent now is one slim bottom toolbar — inline search, a Filters button with an active count, the layout toggle, stats and Today — and everything else moved into a sheet, where 27 project chips wrap comfortably instead of never fitting on a row. Attention docks to the left instead: collapsed it is an 11px amber rail carrying the total and its per-reason counts (blocked, overdue, flagged), expanded it is a panel of the grouped cards with the focus toggle. On a narrow screen the toolbar's amber chip opens that same panel as a bottom sheet — one panel, two shells — and "Clear filters" now resets every narrowed dimension, project selection included.

The calendar becomes the app's sixth tab — last, the position it holds in the web navbar. It is at parity: the calendar filter chips, the needs-a-human rail whose rows tap straight into the agent console, create, edit and delete, the recurrence editor, and executable points with their agent picker, "Run now" and run history. The one deliberate divergence is the month view. Three event chips in every day cell is unreadable at phone width, so a phone shows a month of dots and lists the selected day underneath — a better answer to the question a phone actually gets asked, which is "what is on today?". A wide window has the room, so an iPad puts the titles back in the cells and stands the agenda beside them. Dates and times go through the platform's own picker, held inline so Android does not pop a dialog the moment the field appears.

Someone starting a call you can join now rings the phone through its own incoming-call screen — Answer opens the call, Decline declines it — instead of only surfacing as a banner you had to already be looking at. And calls you take in the app land in the phone's own history afterwards, the way Slack and Teams do: Recents in the iOS Phone app, the dialer's log on Android. Because it is a real system call, two things follow for free: hanging up from the lock screen or the Dynamic Island leaves the room properly, and the system mute button and the in-app mic stay in sync. An unanswered ring gives up after 45 seconds and reads as a missed call rather than ringing on for a call everyone else already joined, and a ring stops by itself if the call it announced is gone. Android registers its calls on the same path; ringing there waits on the push that can wake a closed app.

The web app puts you into a team's workspace, or Personal, and filters every board, bundle, sketch and databank through that lens. The phone had no such idea — team was picked per screen — so two devices could look completely different with nothing on screen explaining why. Now it is the same lens, off the same shared rule, chosen from the account menu and applied to every list. The gear in the header became your avatar, and tapping it opens a sheet that names the account you are actually signed in as before anything else, which is the answer to a whole class of confusion, then Settings, Voice memos, the workspace switcher and Sign out — with the unread ball riding the avatar exactly as on the web. Every header now carries the selected team's colour along its bottom edge, the one piece of always-visible chrome that says whose workspace you are in, holding the last colour as it fades so leaving a team reads as a transition rather than a glitch. The menu's two links that only handed you to Safari are gone: the browser does not share the app's session, so the likeliest outcome of tapping either was a sign-in page.

The app opened straight into Boards and had no home — no answer to what is going on in this workspace, only six lists to go and look in. Tapping the logo opens one now, which is how the web app has always reached its dashboard, so the lockup already meant home in this product and the phone was carrying it on every screen without acting on it. Deliberately not a seventh tab: iOS folds a tab bar past five entries into a More list, and a dashboard that pushed Calendar into an overflow menu would cost more than it gave. Everything on it runs through the selected workspace, so it can never show a board the Boards tab is currently hiding, and it reuses the tabs' own caches — opening it warms what they read instead of issuing a parallel set of requests.

The chat payload has always carried both the conversations you are in and every member of the team; the phone rendered the first and threw the second away. So a teammate you had never messaged was invisible there, and there was no way to start a first direct message at all. The list is sectioned like the web's now — Channels, Direct messages, People — with one filter across all three, and tapping a person opens or reopens the conversation and pushes the thread. People is deliberately not deduped against your existing DMs: that section answers "who is on this team", which a list hiding the people you already talk to cannot do. It also fails softly, since the server does not distinguish its refusals — people stay listed in teams that cannot run chat, and only the action is unavailable. (This was the real story behind "the iPad and the iPhone show different team members": two devices, two accounts, and DM rows are labelled with the other person.)

HardlySimple now has a calendar. You get a personal one, every team gets a shared one, and both appear the moment you open the page — no setup. Month and week views, recurring events that survive DST honestly (a 9:00 standup stays 9:00 when the clocks change), and the whole thing stays live over the same stream the rest of the app uses. The bigger idea is the second kind of entry: an executable point. Instead of tagging a card and hoping an agent's watcher notices, you put the work ON the calendar — pick one of your auto-agents, write the prompt, choose one-off or daily/weekly/monthly — and at that moment the platform dispatches a real console session, visibly, with the run recorded under the point. Each point wears its latest run's status (the same pulsing dot the console uses), and when a run needs a person — the agent asked for review, the session errored, its owner's Claude account went missing — the point turns amber and rises into an attention strip on the calendar and onto your dashboard, which also gained a compact next-7-days view. Scheduled work you can see, with a paper trail when it fires and a flag when it needs you.

Calls ride exactly the same server flow the web app uses: the thread header starts the conversation's call or returns you to it, an accent banner joins the live one, and the call screen is a participant grid with name overlays, mic and camera toggles, a camera flip, Leave — and End for everyone where you are allowed it, behind a confirm. Leaving is idempotent across the button, a dropped connection, the back swipe and the screen unmounting, so the server always hears about it exactly once. This is the feature that graduated the app from Expo Go, since real-time video is a native module: the room loads behind a guard, so everything else keeps working on a build without it and you get a notice rather than a broken join.

An Agents tab with live status and one-tap create, and behind it the console's core loop on a phone. The transcript renders through the same builder the web uses, so the turns read identically, with tool rows you can open. Send a turn, stop one mid-thought, and approve or dismiss a teammate request the agent raised — from wherever you are. It streams over the same events the web app does, dedupes by sequence so attaching mid-turn merges the history with what is arriving live, drops the connection when you background the app so a pocketed phone holds nothing open, and reconnects and catches up when you come back. Setup surfaces stay on the web and say so: credentials, the diff, mindwalks, workflows and sharing.

Tapping a card opens the full detail view, and it is editable: cover, the parent link and detach, the blocked banner, title, the generated TL;DR with a regenerate, the description with its @-mentions rendered properly, subtasks, everything attached — files, sketches, bundles, tables, git refs — assignees, blocked, column, priority, due date, tags, the agent sessions, and the comment thread with its per-comment summaries. Every write round-trips, and the fresh board it answers with lands straight in the board's cache, so the list behind the card is never stale. The board itself grew its first writes at the same time: an inline composer at the top of every column that stays open for rapid entry, long-press for open, move or archive, and the last column's "+N older done" expanding the way it does on the web. Both route ids accept the tsk_ and tb_ forms, so a link from a chat message opens the right card.

The web's carousel comes to the phone as what it always wanted to be — a swipe. The film-strip button on the board header opens the board flattened into reading order, one full card on stage with its neighbours peeking dimmed at the edges, and the card on stage is the real thing: title, TL;DR, description, subtasks, attachments, details, comments and archive all work right there. It is seeded to your own cards when you have any, narrowed by the bottom bar's Mine toggle and by a single-column filter, and the cursor stays PUT when a card vanishes under it — archiving closes ranks and the next card slides in rather than kicking you out of the deck. The strip up top windows around the cursor with chunk jumps past its capacity, and a link carrying a card opens the deck on that card.

The web's omnisearch button, on the phone, bottom-right of every tab. Tap and it opens search over the same engine the launcher uses: debounced, with results stamped by the query they answer so a slow older response can never overwrite newer hits, kind icons, team pills and snippets. Hits with a screen in the app open in the app — a card lands in its detail view — and everything else is honestly badged and opens in the browser rather than dead-ending. Before you type, it shows the pulse instead of static copy: what needs attention and why, and the recent things of each kind. Hold the same button for half a second and it becomes the recorder, with the web's exact choreography — the violet stage balloons out of the button's corner, the recorder column rises, the mic opens with a haptic ping, release saves, and a slide up locks it hands-free. A press that became a recording never also opens search.

Record one from anywhere with the hold gesture — a bare tap is a hint, a flick under 400ms discards, five minutes stops and saves — and the finished, transcribed memo opens the moment it lands. From there the memo screen is a real review surface: the full selectable transcript, and the actionables the model pulled out of it, each with its title, detail and priority, the owner and due date AS SPOKEN, and the verbatim quote it was grounded in. Ask for another pass, tick the keepers, pick a board and file: the cards land in each board's first column tagged memo, honouring the model's own per-proposal routing over your pick and showing that as a hint on the row. Filed rows freeze, badge, and link to the card they became. A refusal — someone else's memo, a board you cannot edit — says what the server said instead of failing quietly.

A Banks tab that reads like the boards list, and a container view that renders the real thing: folders that navigate in place, image rows with proper thumbnails, blobs showing their extension and size, and link rows that name what they point at and dim when there is nothing to open. Every row carries who added it — agents under their companion name — and how fresh it is. Previews follow exactly the web's rules: images full-view, text and markdown as selectable source, diffs colourised line by line with violet hunk headers (including a diff someone saved as .txt), a metadata card for what cannot be shown, the same size cap honoured before anything is fetched, and HTML only ever as escaped text. A knowledge bundle in a databank is no longer a dead end either: it opens to its concept index and reads concept by concept, with both of the web's search arms — the instant filter over paths, titles, types and tags, and full text across the bodies from three characters — and a pasted web link lands on the same screen.

Two more dead ends in a databank open now. A SimpleTable is deliberately not the web's grid on a phone — a spreadsheet you scroll sideways forever to read one record is worse than no table — so each record is a card read top to bottom: the first field as its title, up to three populated fields under it, and a tap opens the full schema including the empty fields, because on a card a blank is noise and in the sheet its "—" is the answer to "does this record have one?". Paging appends rather than flipping, since a phone list is a scroll and not a fixed viewport. Sketches get a tab of their own, each row showing its ACTUAL drawing: the server already renders a scene to an image, so the phone simply draws that — no editor, no embedded browser — with folders, tags and pins as on the web. Tapping opens the sketch on the web, where editing lives for now.

A bell carrying the unread count, and the inbox behind it — team colour bar, who did it, unread dots, older rows paged in, mark-all-read. Opening a row marks it read instantly and opens the thing it is about in the app whenever there is a screen for it. Underneath, the app now holds ONE live connection for everything, the twin of the web's: agent status flips patch the list in place, call banners appear and clear, notifications arrive, and the polls that used to do all this drop to slow backstops. In a chat thread it goes further — the phone dials the same typing room the web does, so "…is typing" shows up on both, and a posted message lands in the thread immediately rather than up to five seconds later. Pocket the phone and the connection quiesces; pick it up and it reconnects and catches up.

A Settings screen with your avatar — picked from the camera roll and uploaded through the same route the web uses — plus name, bio and location edited in place, and sign out. The deeper account surfaces are explicit "on the web" links carrying a line that says why: credentials and token management are set up once, at a desk.

The app was iPhone-only, so an iPad got the scaled letterbox — which no amount of layout work can fix from the inside. iPads are supported now, and rotate freely, while phones stay portrait. Everything keys off the WINDOW rather than the device, so an iPad in Split View is a phone-width app and keeps the phone's chrome; past that width it takes the web's desktop posture instead. The bottom tab bar becomes a left sidebar with labels beside the icons, the header always carries the full wordmark, Boards, Banks and Sketches chunk their sections into two- and three-column grids capped at a readable width, and the chat thread gains the web's split view — the team's conversations stay as a left rail marking the open one, and switching replaces the route, so an afternoon of channel-hopping is one Back and not fifty.

The web mark's motion vocabulary, ported to the phone: the silhouette strokes itself on while the fills come up, which is the sign-in entrance; the mark bobs gently in the top-left of every tab; and the heart beats on tap, where the web beats it on hover. All of it collapses to a still mark under Reduce Motion. The native splash hands off to a pixel-matched in-app overlay so there is no blink between the two — the mark beats once, the wordmark fades up, and the overlay lifts away to reveal the app. Pull a list to refresh and the mark itself redraws until the data lands, instead of floating a stock spinner directly under a logo that sat there doing nothing. The lockup also grew to hold its own beside the header icons, and the iOS app icon's heart went from 43% of the canvas to 66%, which is where Apple's own icons sit.

Leaving a video call could bring the whole realtime process down. Presence rooms hold a dedicated subscriber per socket, and a socket that closed moments after opening — exactly the churn of a call UI unmounting — could tear that connection down while its subscribe was still queued, leaving a rejected promise nobody caught and a process that exits on it. Teardown races are swallowed now, and any other setup failure closes that socket cleanly so the client reconnects, rather than sitting connected to a room that never subscribed to anything.

There is an iOS and Android app now, and this is where it starts: sign in with the same Google account you use on the web — through the phone's own account sheet where that is available — and your boards are there, grouped personal and team, each board's columns snapping past under your thumb with priority, blocked, tags, the TL;DR, counts and assignee faces on every card. It is the same brand down to the details: the heart-gem mark redrawn for the phone in light and dark, the hardly-and-simple lockup, Sora, and an app icon and splash generated from the same source the site uses. Everything it reads goes through one shared package that the web app now uses too, so the two cannot drift on what a card, a date or a name means.

Chat arrives as the app's second tab, gated exactly as it is on the web: only teams that have it are offered, a single entitled team skips the picker, and none shows an explanatory empty state without ever asking the server for chat data. Conversations lead into a thread with sender grouping, day separators, image and file attachments, and message bodies rendered by the same parser the web uses — so a mention is a chip and a task mention opens its card. The composer mirrors the server's rules, including the length cap and keeping your draft when a send fails, and typing @ goes through the same mention machinery the cards use: it offers teammates and tasks, and stores a proper token rather than plain text.

The carousel is already a full-bleed reading mode; f now hands it the whole display, browser chrome and all. While it is on, the first Esc only steps back out of full screen rather than closing the deck under you — and like every other board key, it is listed under "?".

Shipping a release recreated the agent runner, and every live session died with it — permanently. The card stayed claimed, the session stayed stuck on "running" forever, typing into it answered "busy", and Stop went nowhere: a session in that state had no way back. A release is now a handoff rather than a kill. Each busy session is handed a continuation turn before the old runner goes, its CLI is stopped in a way that saves its place, and the next runner picks the session up and carries on from where it was instead of starting the task over or repeating steps it had already finished — measured at about a tenth of a second between the two. Turns you queued while it was mid-thought survive the swap instead of being dropped on the floor. And because a runner can also vanish without warning, a sweep runs at boot and every minute after: any session whose runner is no longer there is resumed the same way, and one too old to resume settles into an error that says so rather than spinning. Meanwhile a session whose runner is gone accepts what you type — it queues and dispatches — and Stop ends it on the spot.

The board has quietly grown a keyboard: "/" jumps to a card, c opens the carousel, h and l flip it, j and k scroll a card, "." repeats your last change, Home and End walk the ends of the deck. Nothing on screen said so — you learned them from a changelog or not at all. "?" now opens a dialog that lists the lot, grouped by the surface that owns them: the board, an open card, the carousel, jump-to-card, the composer. It also names the moves that have no key at all — modifier-click to multi-select, the drag grips, dropping a file onto a card, the card and column menus, the filters — since those were just as undiscoverable. The board and its help text read from one shared table, so a re-bound key can never leave the dialog describing a shortcut that no longer exists. "?" is safe to take: it is Shift+/ and arrives as a "?", never as a stray jump-to-card, and every other chord still falls through to search untouched. The dialog only loads once someone asks for it.

Typing in the board's "/" dialog left you looking at the middle of your own results, and the row it highlighted was not reliably the one you wanted — two separate faults with the same feel. The ranking is the first: matches are now scored before the list renders, weighing title, tags, subtask lines and column name separately on the same fuzzy ladder the rest of search uses, with the weaker fields demoted by whole bands. The top row is the best match by construction, rather than whatever survived the list re-sorting its own rows while React was reconciling them — which is why the winner used to drift from keystroke to keystroke. A hex-ish query stopped matching card ids on the way through, too. The scroll is the second: the list is pulled home on every change to the query, so the first result and its column heading are on screen instead of clipped above the fold. The dialog now also costs a closed board nothing at all.

Being on a call changes what you are likely looking for, but search only ever knew about workspace state — so the file a peer just dropped, the sketch on the stage and "everyone come look at this page" were all unreachable from the one box you already reach for. While a call is live the launcher grows an "In the call" section: Back to the call; Ask for attention, which posts the page you are on into the call chat, raises its unread badge and lands in the activity feed; the last five things shared in the call, with files pointed at their databank page rather than the raw media and links deduped by destination, newest first; and the shared sketch when one is on the stage. Going back to the call leads and takes the default highlight, deliberately — walking into your own call by reflex is harmless, whereas broadcasting a link to everyone is not, so that one sits second. Links a peer pasted only appear if they lead back into the app. Both call-about-the-call rows stand down once you are actually on the call page, and when you type rather than browse, these rows are matched and rendered below your results, so the section can never steal Enter from the thing you were searching for.

A transcript tells you what an agent said it was doing. The new Changes toggle in a session's header tells you what is on disk: the real diff of its checkout, in the same viewer the /diff page uses — per-file cards, old and new line gutters, big files collapsed until you want them. It shows everything since the branch left main, so work the agent committed halfway through a run is in there alongside what it has only just edited, and brand-new files it never staged show up as added files rather than vanishing. The panel says which of those two things you're looking at rather than leaving you to guess, and it refreshes when you ask instead of re-shuffling under you mid-read. Anyone who can watch the session can open it — including someone it was shared with — since the edits were already scrolling past them in the transcript. It needs the agent runner to be up: the checkout lives on the runner's disk, so the page asks for the diff and says plainly when nothing answered.

Until now a teammate could open one of your agent sessions only if it was attached to a card on a board they were already on — which meant a free-form session in the console was yours alone, and there was no way to say "come look at this". A session's ⋯ menu now has Share. Pick people out of your current team, and each of them gets the link as a direct message in that team's chat, which is what actually reaches them — the session opens for them from that moment, card or no card. By default they watch: the same live transcript you're reading, with the requests panel as their way to suggest something. Tick "let them steer the agent" and they get the composer instead, so they can type to it and stop a turn that's going wrong — it still runs on your Claude account, and every turn they take is signed with their name in the transcript, so a run stays readable months later. The permission is a switch per person on the Shared with list: promote someone, demote them, or take the share back entirely, and it lands even while they have the page open. Revoking only takes back what you gave — someone who could already watch through the card's board keeps that.

A board is a wall you scan. Carousel mode is the same cards as a deck you work down: press c on any board (or the film-strip button in the header) and one card fills the screen — the whole card, not a summary, so editing, comments, assignees, attachments and archive all work right there. Arrows flip it, the film strip up top shows where you are in the deck and jumps you anywhere in it, and a dimmed peek of the next card tells you what's coming. It opens seeded to your own cards when you have any, so "my queue" is one keystroke from anywhere on the board, and the filter bar along the bottom narrows the deck further — including down to a single column, which the board itself can't do. Archiving doesn't kick you out: the deck closes ranks and the next card slides in, which is what makes this triage rather than a slideshow. Esc leaves, and one Back exits the whole run rather than walking you back through fifty cards.

The carousel's real trick, borrowed from vim. Assign a card to someone, then flip to the next one and press . — the same person is assigned again. It works for the six changes you actually make while triaging: assignee, column, blocked, priority, due date and tags. The hint along the bottom always names what "." would do next ("Assign Miguel", "Move to Done"), so it's never a guess, and a card already in that state is left alone rather than toggled back — repeating converges instead of undoing. Navigation went vim too: h and l flip cards alongside the left and right arrows, and j and k scroll the card you're on — as do the up and down arrows, which matter because a card taller than the screen used to sit there refusing to move for them. Every one of these stands down the moment you're typing in a field, so a description full of j's still writes itself.

Two small things every open card gained. The Column control now carries a "Push to <next column>" link beside it — advancing one lane is the single most common move on a board, and it no longer costs opening a dropdown and finding the neighbour by name. And the expand icon that lives on the board's card faces now sits on the open card too, next to the title: one tap to the card's own page, where it gets a three-pane workbench and a real URL to share. It's a labelled, thumb-sized target rather than a hover-only glyph, so it works on a phone — where the modal is full-screen and there was previously no way through at all.

The oldest failure in a video call — a whole answer delivered to a muted microphone — is invisible and inaudible to the person making it, which is exactly why the call has to say it out loud. Muting doesn't close your microphone, it silences what's published, so the app can listen to a private copy of the same track: nothing extra is opened, there's no second permission prompt, the room still receives silence, and only a loudness number ever leaves the meter before the next tick throws it away. The judgement is tuned to how people actually talk — a floor that learns the fan in your room but can't be raised by your own voice, a window that drains rather than resets between syllables, a hold that survives a breath mid-sentence, and a pause before it can fire again so it never strobes. When it does fire, four things say so and none of them are visible to anyone else: a red banner above the controls carrying Unmute itself, plus a wave-off for when the side-talk is deliberate; the mic button lit; a bar across the foot of the picture-in-picture, for the call you've minimized; and an alarm ring on your own tile, which now sits under the call's own chrome instead of painting over the controls.

The gap between camera-on and camera-off, for when you want to be present without being watched. Blockify (press p) downsamples your picture to a coarse grid of isometric blocks that carry your colors and rise where you move. Color, presence and movement; never a face. It shows the same way to everyone, your own tile included, so what you see is what the room sees, and late joiners get it instantly. It's one key, the ⌘K menu, or the ⋯ sheet away. To be clear about what this is: it's expression, not privacy — the veil is drawn on every screen, but the underlying video still reaches the room, so treat it as a way to soften how you appear rather than a guarantee about what leaves your machine.

Every card and column drag handle carries an instruction for screen readers — "To pick up a card or column, press space or enter…" — and on taskboards, the sketches sidebar and databanks that instruction had quietly become unreachable. The handles were pointing at a description that no longer existed, because the id they were served with and the id they were rendered with disagreed the moment the page came alive in the browser. Keyboard drag itself always worked; what was missing was anyone telling you so. Fixed at the root for all three boards.

Writing a phone number as a link in a task, comment, memo or knowledge concept produced something worse than plain text: tapping it reloaded the page you were on. Markdown's link handling had two separate gates on which protocols survive, and tel: passed neither, so the address was blanked out into a link back to the current page. Both now let tel: and sms: through, so a number written as a link dials on a phone and a text link opens the composer — and because these hand off to another app rather than loading a page, they no longer open a doomed empty tab first. Everything else about link handling is unchanged: no scripts, no new tags, no new protocols beyond those two.

Transcription used to run whenever the team was entitled to it, and the Captions button only opened the panel: the app could transcribe an entire call while showing no sign of it anywhere, and nothing in the room could stop the capture. Both halves are closed. A pulsing red "Recording" pill now sits in the call header, and a REC chip rides the picture-in-picture — a minimized call is still recording, and that is precisely when nobody is looking at the call chrome. Clicking the pill opens the transcript, so "am I being recorded?" and "recorded as what?" are one click apart. And any participant can stop it, from the ⋯ sheet, the ⌘K menu or the transcript panel — no role required, because being recorded with no recourse except to leave is the worse failure. A stop is final for that call: the next person to join can't quietly restart it, and both the panel and the filed transcript mark where capture ended, so a transcript that simply stops can't be mistaken for one where nobody spoke.

In team context the conversation was always two hops away: the team strip in the account menu went to the team overview, and chat was one of six quick links there. Now a "Team chat" row sits directly under that strip — same accent border, so the two read as one team block — and lands you in the conversation in one click. It only appears where chat is actually switched on for the team, so the shortcut never opens onto a gate. The strip itself also learned the team's proper address and skips a redirect on the way to the overview.

Filing a memo's actionables as cards used to be a quiet act: the cards were created, but a board already open — yours in another window, or a teammate's — didn't hear about it and showed nothing until someone reloaded. Filing now announces itself the way every other card change does, so open boards repaint on their own: the new cards surface in the leftmost column the moment they're filed, on every screen watching that board. Actionables filed from a call transcript ride the same path, so they got this too.

A card that links a commit or a pull request could tell you the work existed, but reading it meant a trip to GitHub. Now there's a diff view in the app: next to each linked commit, PR, or branch on a card sits a small diff button that opens /diff — the change laid out file by file, additions and deletions tinted, big files folded until you ask for them, renames and binaries labeled for what they are. Pull requests carry their open/merged/closed state and author; commits their message. Mindwalks join in: a walk captured from a repo-wired agent session grows a Diff link in its header, so after flying through where the agent went you can read exactly what it changed — the session's branch compared against the repository default. The page fetches with your own GitHub token (public repositories work without one), sees only repositories you can already see, and when a diff is too big to load whole it says so and shows the first part instead of pretending. GitHub-hosted repositories for now; refs on other forges keep their plain link out.

Holding the lightning button to talk meant holding it the whole way through. Now slide your finger — or your pointer — up about an inch while you hold, and the recording locks hands-free: the gesture messaging apps already taught everyone, with a "slide up to lock" hint floating beside the button while the hold is still live and a short buzz to confirm it where the hardware has one. Once locked it behaves exactly like a recording started with ⌘I — it keeps listening until you stop it. "Record a memo" also became something search can find. It's a starter row the first time you open search with nothing typed; it appears under your results whenever what you typed reads like recording intent ("mem", "rec", even the typo "recrod"); and typing memo, memos or voice opens the memos list with recording as its first row, so Enter on the bare word starts talking. Ordinary queries like "meeting notes" stay clean. The help dialog now tells the whole story too: the ping, the slide, ⌘I both ways, and Esc.

Press-and-hold used to do four things inside the same half-second: wash the screen violet, raise the recorder, open the microphone, connect the captions. The wash was the most expensive of them — it re-blurred the whole page behind it on every frame — and it was stealing exactly the frames the recorder needed to start. It's one choreography now, each step waiting on the one before it. The violet stage sweeps in alone. The recorder column then rises onto a settled sheet already wearing its "Connecting the microphone…" face, so no text swaps mid-rise. Only once that has arrived does the microphone actually open — and the instant it is truly capturing, a short two-note ping plays. That answers the question the old version left you guessing at: can I talk yet? Yes, when you hear it. Underneath, the frosted backdrop is rasterized once instead of recomputed per frame. Let go too early and you get the same "that was too short" nudge; press ⌘I or Esc while the reveal is still crossing the screen and the whole thing ends without ever having started.

Every review finding still open across the last ten merged changes was closed in one pass, along with a few that turned up beside them. The ones you would notice: holding M in a call no longer machine-guns the microphone on and off — a held key repeats, and the handler now ignores the repeats — and the End call confirmation re-arms itself when you dismiss it or it fails, instead of leaving End dead for the rest of the call. The desktop search popover stopped opening already scrolled: its starter rows were taller than the box, and with the scrollbar hidden the clipped first and last rows read as a rendering bug. On taskboards, a title long enough to be split now keeps your existing description word for word, and the composer stops you at the limit rather than after it. The live 3D map polls only the events it actually draws instead of every row in the session. An agent run that errored is filed as an error — one that failed without naming a reason used to be titled "Run ended: success", which is precisely the card you scroll past. And two agent tools that answered a public board id with a raw database error now answer with the board.

Three call-lifecycle fixes from one live group-call session. The last person to leave now ends the call — the room used to linger "in progress" for up to ninety seconds after everyone walked out, blocking a fresh call in the same channel; an explicit leave that empties the room closes it on the spot, and the channel is free again immediately. Joining the same call from a second device stops reading as a catastrophe: the older connection used to announce "The call ended." (it hadn't) and two devices on one account could ping-pong that at each other forever — now the message names the real cause, "you joined from another device," being removed says so, and only a genuinely ended call claims to have ended. And under the hood, that second-device handoff no longer mis-marks you as having left, which kept the roster honest enough that the new last-leaver rule can never end a call someone is still on.

The in-call control bar showed eleven icon buttons — every feature, all the time, ambiguous at a glance and cramped on anything narrower than a laptop. It now carries only the controls you actually reach for mid-conversation: mic, camera, screen share, chat, Leave and End. Everything else (camera options, sketch sharing, layouts, captions, the activity feed) lives one tap away behind the ⋯ menu — which shows a badge when something folded away has unread activity — and in the call's search. That search moved out of the bar into its own round button, bottom-right: the exact corner the omnisearch lightning button owns everywhere else, answering the exact same keystrokes (⌘K, ⌘/, ⌘⇧F). On a phone it opens pinned to the top of the screen like omnisearch does, above the keyboard instead of underneath it; on desktop the menu now uses real vertical space instead of scrolling inside a short box. The letter shortcuts stopped caring about your Shift key or CapsLock — M mutes, m mutes; C is the camera either way. And recording a quick memo with ⌘I always wins over the call's own shortcuts, because "say it instead of typing it" matters most mid-call.

The omnisearch lightning button learned a second trick: long-press it (or hit ⌘I from any page, even mid-typing) and a recorder opens on the spot — speak, press ⌘I again to stop, and the memo is saved, transcribed, and mined for actionables like any memo recorded on the Memos page. Escape discards. No navigation, no losing the page you were on; the thought goes in the moment you have it. The recorder shows a live level meter while it listens and an actionable dialog when it's done, and the whole flow honors the same keyboard-first contract as the search: the chords work while your cursor is in a text field, because that is exactly when you want to speak instead.

The top bar was collecting one icon per feature. Memos and Mindwalks no longer sit there — like knowledge bundles, SimpleTable and the Auto-agent console before them, they're now reached through Databanks, the hub for everything your workspace holds. Open Databanks and the header links take you straight to each surface; the old addresses still work, and everything stays one omnisearch away (⌘K, type the name). Toasts calmed down too, in the other direction: notices are now small pills that drop in top-center — where your eye already is — instead of full-width cards squatting bottom-right over the omnisearch button and the in-call controls. One of them literally covered the call's new search button; none of them can now.

Capturing a session as a 3D city used to be a menu item you had to remember. Now the runner does it for you: every time an agent finishes a turn, its walk in Mindwalks refreshes to match — so a card an agent picked up by tag grows its city as the work happens, with no one asking for it. Two places show it off. In the console, a new map toggle in the session header opens a live city that updates every few seconds while the agent runs, replaying the newest file touches so you can watch the light move through the repo mid-session. And on a task card, the Attached list now carries a chip for each walk you own over that card's sessions — one click from "what did the agent do here?" to flying through it. Agents got the same power over MCP: a zero-argument capture_mindwalk captures the calling session (or any session you could already watch) and hands back the link to paste in a comment. Auto-capture skips sessions that never touched a file, refreshes in place rather than piling up copies, and keeps any name you gave the walk.

The other half of handing files around. An agent could see that a PDF was attached to a card and read none of it: the link it was given was gated on a browser login, so an agent that followed it landed on a sign-in page. Attachments now come back as text. A PDF is extracted page by page, a Word document or a slide deck the same way, and the page and slide markers are kept so the agent can tell you where a passage came from — while a scanned PDF with no text layer says so and hands over a real download link instead of pretending to be empty. Size stopped being the wrong question too: a document is judged by what it costs to read rather than by a raw-bytes cap meant for images, so a 10 MB specification is readable instead of refused. Files attached to knowledge-bundle concepts had the same dead end and got the same way out, and reading a databank file can now ask for extracted text as well. One quieter fix rode along: when an agent reports that something on the platform got in its way, the report is now actually recorded — on real auto-agent sessions it had been going nowhere, silently.

Since the start of August a session's ⋯ menu could hand you a file for mindwalk — the local tool that replays a coding run as light moving over a 3D map of the repo — and everything after that happened on your machine: install the tool, download the log, point it at a checkout. That map is now a page of its own. Pick “View 3D map” on any session you can open and it is captured as a mindwalk: every file the agent touched becomes a building sized by how often the agent came back to it, directories become the districts they sit in, and pressing play flies a point of light from file to file in the order the work happened — reads in blue, edits in amber, searches in violet, commands in green. The four-minute build that stalled the real session is compressed to a beat on the way through, your own turns sit as ticks on the scrubber, and the corner clock keeps honest session time. A capture is a snapshot, so it keeps playing after its session is deleted, and capturing the same session again refreshes it rather than piling up copies. A teammate watching a task-bound session can capture their own — the same content they could already read on screen. The export to the local tool hasn't gone anywhere; it's the next row in the same menu.

Typing out the whole thought in the "Add a card" box used to end badly: past a couple of hundred characters the card refused to be created at all, and the only way forward was to cut your own text down before the board would take it. Now the long version is the point. Whatever you write is kept — the card takes a scannable headline off the front of it for the title, and the full text lands in the description, where it belongs. The TL;DR is still written from everything you typed, so the card reads as a headline, a one-line gist, and the detail underneath. The composer shows you the title it's about to use before you commit, so nothing is a surprise. The same applies to a card's title field, to a subtask, and to anything an agent files through the MCP tools — a long title is laid out across the card instead of bounced back as an error.

Open a card on its own page — the link a notification hands you, or the one an agent leaves behind — and you got the pop-up card's proportions pasted onto an empty screen: a column not much wider than a phone's, the rest of a big monitor left dark, and the description, the thread and the details all queued up in a single scroll. On a wide screen that page is now laid out for the room it has. The description keeps a comfortable reading width instead of stretching into lines you lose your place in, the comments get a real column rather than a track that wraps every other word, and the details rail fits on screen whole instead of being something you scroll to. Each of the three scrolls on its own, so a long thread and a long description stop fighting over one scrollbar. Anything narrower than that is untouched — it is the same card you get when you open one from a board. The parts that should stay put still do wherever you are: the parent link, the blocked banner, and any agent requests waiting on you. The back link names the board it returns you to now, too.

A file in a databank printed “quarterly-report.pdf · 2.1 MB” in muted grey underneath a heading that already read quarterly-report.pdf — so the one line the tile had spent most of its width repeating the title, and buried the thing you were actually scanning for. Files now lead with their type: PDF, CSV, XLSX. The name only prints when it says something the heading doesn't. The label is read off the file's name rather than what the upload claimed to be, because uploads arrive claiming nothing in particular often enough that trusting them would badge half a databank “FILE”. When there is genuinely nothing to go on — no name, nothing declared — it says nothing rather than inventing a label.

“Sent a request to your agent” arrives as a notification and takes you to the card — which was, until now, the one surface with no way to answer. Approving and dismissing lived on the auto-agent console, so the notification reliably dropped the only person who could act somewhere they couldn't. A card with requests waiting now meets you with them, at the top beside the blocked banner: who asked, what they asked for, and the same two answers the console gives — send it into the session as a turn from them, or dismiss it. Sending is held while the agent is mid-turn, exactly as it is on the console, and there's a link through to the full transcript when you want to read what led here. Only the agent's owner gets the buttons, because it's the owner's call; everyone else on the card can see that requests are waiting, which is usually the answer to why a session has gone quiet. The two surfaces stay in step — answer in one and the other stops asking.

On a laptop, search opened a narrow column in the middle of a wide screen and had nothing at all to say until you started typing. It now opens as two panes: the list you type into keeps its corner, and a rail fills the space beside it. Before you type, that rail is what's asking for you — work assigned to you that's blocked, overdue or due soon, with what has recently moved in the workspace underneath, and a picture of the top item when it happens to be a sketch. As you arrow down the results it shows the highlighted one in full, with the matched words marked inside the surrounding sentence instead of stripped out of it. Narrow to a kind — tasks, sketches, files — and it narrows with you. It starts loading while your pointer is still on the button, so the panel is usually already filled by the time it opens, and each pane scrolls itself. Phones keep the full-screen sheet they already had, and a narrow window keeps the single column.

Search has had a bit of a show on a phone since the end of July — the purple button balloons out of the corner, a violet sheet fills the screen, and the bar drops in with a spring past its resting place. On a laptop it did none of that: the same button quietly resized into a panel over 300 milliseconds and stopped. Two different animations, and only one of them had ever been given any attention. The desktop panel still grows out of the button rather than taking over the screen — that's the right shape when you have room — but it now springs open on the same curve the phone uses, with a violet wash sweeping out of where the button just was and the rows lifting in behind it. If you have asked your system to reduce motion, the wash doesn't run at all and everything simply appears.

Sketches have kept restore points since the end of July, but reaching one meant opening History and picking it yourself. Now you can tell the sketch assistant “undo that” or “put it back” and it does the looking — it reads the restore points and rolls the canvas back to the one you meant. It is deliberately honest about its reach: restore points cover writes made by the assistant and by other agents, not your own drawing, which is what the editor's own undo is for. If the history doesn't hold what you're describing, it says so rather than restoring something close but wrong. Agents working over MCP gained the same two abilities, so an agent that makes a mess of your canvas can now clean up after itself. Restoring is still undoable either way — the drawing it displaces becomes a restore point of its own.

A table with two dozen fields was being read through a letterbox: the grid sat inside a fixed-width column with a wall of field badges stacked above it, so the columns scrolled sideways in a narrow strip and you lost track of which row and which column you were on. The table now takes the full width of the window and whatever height is left over, and it is the grid that scrolls rather than the page. The header row stays put as you scroll down, and the row numbers and the first field stay put as you scroll sideways, so the thing that tells you which record you're looking at never leaves the screen. On a phone that pinning is dropped — a gutter and a frozen column would eat most of the width there.

Turning your camera off replaced you with a stock silhouette, so a call where everyone had their camera off was a wall of identical strangers told apart only by name tags. Your avatar now travels with you into the call, handed out as part of joining, so it is right the moment you appear — including in the picture-in-picture window, where none of the call's own data is loaded. Video, the speaking ring, your name and the focus toggle are all untouched. A second pass caught the other end of it: someone with no display name at all used to get a letter sliced off their raw user id, a face nobody recognises, which is precisely the failure this exists to prevent. They get a neutral “?” now instead.

Typing @ in a comment opens the list of people and cards you can mention, anchored above the box — the chat convention, and the right call when the box sits at the bottom of the screen. In an open card it often doesn't: the comment box can end up near the top, and the list went up into nothing, leaving you one clipped row and no hint there was more above it. It now measures the space it actually has and drops below the box when there isn't enough room above, with a floor so it never flips into a useless sliver.

“/” is meant to open the quick search on a taskboard. Instead it crashed the page outright: the search parts were being rendered without the root they read their state from, so the first one to go looking took the whole board down with it. The board header's search button and “Nest as subtask” went through the same dialog and were broken in the same way. Every other search surface — the main search, the pickers, sketch sharing — builds its own root and was never affected.

An agent that produced something — a report, a config, a script — often couldn't actually give it to you. The recommended upload route needs network access out of the sandbox, which the sandbox blocks outright, and the fallback of pasting the file in as base64 was arriving altered: 1233 bytes sent, 1236 received, on a file barely over a kilobyte. One real session ended with three files pasted in by hand. Most of what an agent writes is text, and base64 was adding a third to its size and a corruption surface in exchange for nothing, so uploads now take the text itself and store it exactly as sent. Verbatim means verbatim — line endings are not tidied up on the way through, because a file that comes back different from the one that went in is the whole bug. The file types on offer were trimmed to the ones the upload rules actually accept, so an agent is no longer told it can send something that will be refused.

A long session is a wall of tool calls, and the shape of the work — which corners of the repo it kept returning to, what it only touched once — isn't in there anywhere. mindwalk is a free tool that replays a coding session as light moving over a 3D map of the repo, and any session you can open now has “Replay in mindwalk” in its ⋯ menu: it hands you the session as a file and the one line that plays it. Nothing about the session goes anywhere — the file downloads to you, and the tool reads it on your own machine. Tell it where your copy of the repo lives and the agent's paths are rewritten onto yours on the way out, so the map is built from files you actually have. A teammate watching a session attached to a task can export it too — it's the same content they're already reading on screen — and a session that hasn't said anything yet has nothing to hand over.

Actionables pulled out of a voice memo or a call transcript could become cards, and an auto-agent could pick cards up — but only if you remembered the tag it watched for and typed it on every one. Filing proposals now has an agent picker beside the board picker: choose one, and the cards it creates carry that agent's tag, so its next round picks them up on its own. Choosing nobody is still the default and still exactly what it always did. You can also offer one of your agents to a team now, from the agent's settings on the auto-agent page — its members get it in that picker and can send it work, while it keeps running on your Claude account, seeing only what you can see, changeable and switchable-off by you alone. The picker only lists agents that could actually answer (switched on, watching something, with an account behind them), and if some of the cards land on a board the agent's owner can't see, it says so rather than leaving you watching for a session that will never start.

Putting a sketch on the call used to take the call over: the canvas filled the stage and existed nowhere else, so looking at anything else meant taking the sketch back down. A shared sketch now keeps a tile wherever everyone else has one — in the gallery grid beside the faces, featured in speaker view, in the filmstrip next to a screen someone's presenting — and clicking it anywhere puts the live board on stage. A presented screen is one click back the same way, so a screen and a sketch can both be up and each person picks what they're looking at. The tile you're not focused on shows a picture of the board rather than the working canvas, and stops refreshing while the tab is in the background, so a call with a sketch on it costs about what a call without one does.

Making a sketch, knowledge bundle, databank or table for your team needed to be an owner or an admin of it. If you weren't, picking the team didn't warn you — your work just quietly became personal, and the teammates you made it for got “you don't have access to this” on the card you attached it to. Anyone in a team can now file work in it, and the team picker offers every team you're in rather than only the ones you run. Attaching something of yours to a card on a team board now shares it with that team as you attach it, which is what attaching it always looked like it did — and things already attached before today were repaired in place. Sharing never costs you the thing you shared: whatever you made stays yours to edit after it moves, and team managers can tidy anything the team holds. Everyone else reads and copies — except sketches, which stay a canvas the whole team draws on. Nobody gained sight of anything: reading a team's work was already open to its members, so this only widens who can put work there.

A databank full of sketches was a wall of identical lightbulb icons — no way to tell which one you meant without opening each. Sketch cards now show the drawing itself, redrawn from the sketch as it is right now, so an edit turns up on the card without a reload. It's the picture you're allowed to see: a sketch you couldn't open before still doesn't render one. The trip back works too. A sketch is usually one artifact of a wider piece of research, and opening one — from a card, a search result, a teammate's link — used to strand you there. The header now says which databank it's filed in and links straight to it, with a menu when it's in several, and nothing at all when it's in none you can see.

A proposed task is a first draft, so you can now correct one instead of only taking it or leaving it. Edit the wording yourself and the row says it's yours — the line that was actually said stays put underneath, because that part isn't yours to rewrite. Or tell it what's wrong (“this is about the mobile app”, “split the deploy out”) and press Re-evaluate: your instruction outranks its previous wording, but not the transcript — it still has to quote something somebody really said, and if it can't do better you keep the version you had. Each proposal also picks its own board now, from the boards you can see in that team, and you can move any of them: accept five and three can land on Platform while two go to Design, in one press. Anything already filed as a task is left alone — that card is the thing to edit by then.

Open search and there's a Teams shortcut next to Boards, Sketches and Databanks. Pick it and you get the teams you're actually in — not an index page, not a switcher buried in the account menu — and typing narrows them as forgivingly as everything else does. Typing teams does the same thing without the click; before, that word only told you to type more. Pick one and you land on it, with that team now the workspace you're working in, so the boards and sketches you see next are its. It's the one browse list that isn't scoped to the workspace you're in, for the obvious reason: it's the list of workspaces.

When a call ends its transcript already lands in the chat. Now that message has a Find actionables button: press it and the transcript is read back for the things the call actually committed people to — and because it knows it's reading a conversation, it names who took each one on. “Priya can you bump the volume to two hundred gig?” proposes a card that says Priya, and “I'll send that over before Friday” proposes one that says Friday, both with the line that was actually said. Nothing said in passing becomes a task: you tick the ones that are real, pick a board, and only then do cards appear — tagged so the board shows where they came from and linking back to the conversation. Whoever can read the thread can do this, one read per call however many of you press it, and anything already filed can't be filed twice.

A memo is usually you telling yourself to do three things. There's a Find actionables button on every memo now: it reads the transcript back and proposes the things that were actually asks — not the opinions, not the bits you said were already done — and shows each one with the words you actually said, so you can tell at a glance whether it heard you right. Nothing becomes a task until you tick it. Pick a board (it starts on the one for the workspace the memo is in), press Create, and the cards land carrying the memo they came from, who spoke it, and the quote. Each proposal then links to the card it became and can't be filed twice. Names and timings it heard — “Marcus”, “before Friday” — stay written as what you said instead of quietly becoming an assignee and a due date. And if there was nothing to do in the memo, it tells you that too.

The word was doing nothing for you: typing board searched everything for the letters b-o-a-r-d and handed you tickets with “board” in the title. Now board on its own opens this workspace's boards — the same list the Boards shortcut gives you — and whatever you type after it narrows that list. Same for sketch, databank, bundle and memo. The narrowing forgives you: half a word, initials (ds finds Design system), a transposed letter, or the words in the wrong order all still land on the thing you meant. Matches in your other workspaces come below under their own heading, so nothing you could reach before became unreachable, and opening one switches you to that workspace. If you really were searching for the word, there's a row that says so and widens the search back out. The kinds with no list to show — tasks, concepts, tables, teams — now say what to type instead of quietly returning noise.

Open search and pick Boards, Sketches or Databanks and you get a list of what's actually in the workspace you're in — then keep typing to narrow it, instead of being dropped on an index page to start over. Search also answers to more than one shortcut now — ⌘K, ⌘/ or ⌘⇧F (Ctrl on Windows and Linux), all of which work even mid-sentence in a text field. A new “How search works” entry explains the parts that aren't obvious: those shortcuts, that a leading type word (board onboarding, sketch logo, memo standup) searches just that kind, and that results from your selected team come first. On a phone the panel now stops at the edge of the screen and scrolls its own list — dragging it used to scroll the page behind instead, which made a long list feel broken. Escape steps back out of a list before it closes the search.

Connecting a repo to the auto-agent used to mean handing it a JavaScript lockfile or being told there wasn't a supported one — which ruled out a WordPress plugin, a PHP service, or anything that keeps its dependencies elsewhere. Repos are now read for what they actually are: their stack shows as a pill in the console, PHP and WordPress ones run with php, composer and wp-cli on hand (and get checked for PHP mistakes rather than JavaScript ones), and a repo with no dependency manifest at all gets a plain checkout instead of a refusal. You can pin the stack yourself if the guess is wrong. Sessions also stopped waiting on image builds: a session picks up a prepared image and starts, and a dependency bump lands in the shared workspace instead of quietly triggering a rebuild while you watch a spinner.

The console's right rail has a Workflows panel: named step-by-step recipes an agent can be pointed at, each showing where it came from (written by hand, proposed by an agent, or mined from behaviour repeated across runs), which version you're looking at, and its whole body when you expand it. This first slice is deliberately read-only — reading a recipe's steps before anything acts on them is the entire point, so every one of them sits as a draft, and the switch that makes one live ships with the review flow it needs. Agents can read the same list over MCP, so one can check what recipe already exists before improvising its own.

Hold the record button and the bubble above it opens immediately with a spinner, then fills in with your words as you say them, one word at a time. A cold microphone and a cold connection take a second or two, and for exactly that long the button used to look like it wasn't doing anything. Older words scroll out of the top, so the newest line is always the one you're reading — five lines on a laptop, three on a phone. The bubble's space is reserved whether it's open or not, so the button never jumps out from under your thumb mid-sentence. If live captions can't run on this server it says so instead of spinning forever: you're still recording, and the memo is still transcribed when you let go. Watching your words costs a second, dearer pass over the audio, so there's a Live captions switch under the button to turn it off — and every memo shows what transcribing it cost, estimated from its length and the published per-minute rate, with a running total for the workspace.

Clicking a file — the call transcript posted to your chat, a shared .md, a pasted log — used to save it to disk and leave you to find an app that opens it. Files now have a page: the writing is rendered right there, code and data show as source, images and PDFs display inline, and Download is a button you press when you actually want the file. It works the same from a chat message or from the databank board, so a transcript is something you read in a tab rather than a mystery file in your downloads. Very large files still hand you the download, and say why.

There's a microphone in the navbar now. Hold the button on /databanks/memo, talk, let go — the recording is transcribed and saved as a memo titled with your first sentence, alongside who recorded it, when, and how long it ran. There's no form and no save step: the memo lands in whichever workspace you have selected, because the whole point is that talking is the only thing you have to do. On a team, anybody can record one, and only the person who spoke (or a team manager) can delete it — nobody rewrites your words. The audio itself isn't kept; the transcript is the thing, and it turns up in search like everything else.

“Copy this sketch to my personal” used to earn you a polite refusal and directions to a Duplicate button that doesn't exist. Now the assistant just does it: the whole drawing — style, tags, and named marks included — lands in a brand-new sketch in your personal space (or filed to the sketch's team, if you ask and can manage it), and the reply links you straight to the copy. The sketch you're looking at isn't touched, and the copy starts its own history at version one. Agents working over MCP got the same one-call copy, duplicate_sketch, instead of re-uploading an entire scene to clone it.

Paste a hardlysimple.com link — or let an agent write one into its transcript — and clicking it used to treat your own site as the open internet: an “Open external link?” confirmation in agent transcripts and sketch chat, or a new tab and a full reload from task descriptions, comments, knowledge bundles and chat. Our links now open in the app, routed like any other click, no interstitial. Links to anywhere else still ask first, and the check isn't fooled by look-alikes — hardlysimple.com.evil.com is still somebody else's website.

Hit Captions in a call and what everyone says appears as it's spoken — a docked column on desktop, a sheet on your phone, sharing the side panel with call chat. Captions keep accruing while the call is minimized to the corner, and joining late catches you up on what was already said instead of starting you at silence. Only microphones are transcribed, so a shared tab playing music doesn't end up in the record. When the call ends the whole transcript is filed into the team databank under transcribe/ and posted into the conversation, so “what did we decide?” outlives the call; a call where nobody spoke saves nothing. It's off until a super admin turns Live call transcription on for the team — audio leaves for a transcription service, so that's a deliberate per-team choice — and it takes effect on the next call.

When an auto-agent picks up a card, the whole board no longer has to take the owner's word for it: the card now lists every agent session on the task, and any teammate who can open the card can watch the session live — the same transcript the owner sees, tools and all, streaming in real time. Watching is strictly watching: the controls stay with the owner. What you get instead is a request panel — "please have it update the docs too" goes to the session owner, who gets a notification and a strip above their console where one click forwards your ask into the session (attributed to you) or dismisses it. Either way, you're told what happened to it.

Every time the sketch assistant (or an MCP agent) is about to change your canvas, the scene it's replacing is saved first. The new History button in the sketch header lists those restore points with a thumbnail of each — pick one and the canvas returns to that state, live for everyone in the sketch. Restoring never destroys anything either: the drawing it displaces becomes a restore point too, so you can roll forward again. Old snapshots thin out on their own — the last ten stay, then one per hour for a day, one per day for a month — recovery without hoarding every keystroke.

Opening or closing a task used to re-run the whole board on the server before anything could move; the click just froze. The card now opens and closes entirely on the client — the URL still updates, stays shareable, and Back/Forward still work. The board also stopped downloading the full card machinery (editors, comments, mentions) before it could paint: that arrives quietly in the background, so the board lands lighter and the first card you open shows its frame immediately. And the card itself finally behaves like one thing: click anywhere on it to open (⌘-click anywhere to select for bulk actions), dragging across it no longer paints a text selection, and while a card loads, its comments, attachments and subtasks show placeholders instead of prematurely claiming "nothing here yet".

A repo can now commit .hardlysimple/harness.json — its auto-harness: how to install it, start the dev server, and which checks prove a change works. Agents picking up a card on that repo get those commands in their kickoff instead of guessing, and they're asked to run the verify gates before calling anything done. No file yet? The runner drafts one from what the repo already declares (lockfiles, scripts, Taskfile, compose) and labels it as an unreviewed draft — and agents that learn a repo the hard way are asked to leave the file behind for the next one. Sync it by hand with the new sync_repo_harness MCP tool, or let the env-cache build do it on its own.

Databanks take as many files as you throw at them: drag a folder's worth straight off your desktop onto the board, or pick several at once in the file dialog. Each file gets its own progress bar while it uploads — so a big PDF no longer looks like a hung page — and items appear as they land rather than all at the end. Anything the workspace doesn't accept is skipped with a note instead of failing the whole batch.

⌘-click (or shift-click) databank items to select a run of them and a bar slides up: move them into a folder, add a tag, strip a tag, or remove them — one confirmation for the whole batch instead of one per item. There's a sort control too (name, newest, kind), and when you sort by anything other than your own manual order the drag handles hide, so the board never implies a drop will stick where it won't. Tag filters gained an Any/All switch, for narrowing instead of widening.

Bundles whose concepts carry paths like tables/users and audit/summary now read as a collapsible tree instead of one long flat list, and each bundle remembers what you had folded. The box above it matches path, title, type and tags as you type — and past a few characters it searches concept bodies on the server too, showing the matching passage with your terms picked out. Useful when you remember a sentence but not which concept it lives in.

Everywhere the app renders Markdown — knowledge concepts, task descriptions, comments — fenced code is now syntax-highlighted, in both light and dark. Headings carry a quiet # you can grab a link from, so you can point someone at one section of a long concept, and long concepts grow a contents rail you can click through. The highlighter only downloads when a body actually contains code, so short comments stay exactly as quick as before.

A busy card — especially one an agent is working through — could bury everything else in your bell. Each notification's ⋯ menu can now mute that task, or its whole board, and muted scopes quietly stop notifying you while everyone else keeps theirs. The list also stopped stopping at thirty: a Load older button walks back through your history.

The agent console gained a Harness panel: the last suite run scenario by scenario, a small trend strip that exposes anything which used to pass and doesn't any more, and what each scenario cost to run. It can also run itself — set one environment variable and the runner works through the cheap scenarios nightly, leaving an attention comment on your harness board the moment something flips from passing to failing, rather than waiting for you to check.

A filter bar above the columns: assignee, tags, priority, due date (overdue, due within a week, no date at all), and a My cards toggle. The filters combine, each column tells you how many cards it's hiding, and the whole view lives in the URL — so a filtered board is just a link you can paste to someone. Your last filter is remembered per board for the next visit.

Hit / on a board — or tap the new search button — and a palette opens over every card on it, matching titles, tags and column names. Enter flashes the card, scrolls it into view, and opens it. It deliberately looks past your active filters, so you can still find something the filter is currently hiding.

⌘- or shift-click cards to select them and a bar appears: move them to a column, assign someone, add a tag, mark blocked or unblocked, archive. Escape clears the selection, and it survives changing filters — so you can filter down to exactly what you meant, select it, and act. Cards that leave the board drop out of the selection on their own.

Web comments were delete-or-live-with-it while agents could freely edit theirs, which meant your own typo outranked you. Your comments now have an Edit action in both the group-chat and classic views, with the same @-mention picker as the composer, ⌘-Enter to save and Escape to back out. Edited comments wear a quiet (edited) marker, and the one-line summary regenerates from the new text.

Dragging a card now narrates itself — picked up, what you're over, where it landed — including the nest-as-subtask zones, which a screen reader previously couldn't perceive at all. Nesting gained a keyboard route too: a Nest under… action on the card menu that lands in the same place a drag would. Around the app: every button clears a 44-pixel tap target on touch, a Skip to content link starts the tab order, the live-companion count announces when it changes, and the installed app's icon and bottom bars respect the safe areas on notched phones.

Every change on a board used to broadcast the entire board to everyone watching it — a single comment shipped every card to every viewer. Now a change sends a small nudge and each browser refreshes only what it's actually showing. On a hundred-card board that's about a thousand times less traffic per comment, which you notice most on a phone or during a call. Posting a comment also appears instantly instead of after the round trip, and “Show N older” no longer snaps shut the moment someone else edits something.

A pass over the slowest reads: pages that used to fetch a dozen things one after another now fetch them together, the “what changed recently” queries got a real index behind them, and writing a batch of knowledge concepts happens in one go instead of one at a time. The sections that stream also got proper skeletons, so the boards page and the agent console sketch themselves out immediately rather than flashing blank.

Search results, link previews and the install prompt were all still advertising an older product — an infinite canvas and a taskboard. They now describe what this actually is: a shared workspace your AI agent can use, over one MCP endpoint, with every action attributed. /llms.txt was rewritten for the audience that reads it (agents) with the endpoint, both ways to connect and the full route map. And the tool count comes from the server itself now, so the three pages that each quoted a different number finally agree.

The scroll film had exactly one call to action, at the end of a very long page. Now each act closes with a way in — get started, or connect your agent — and past halfway a dismissible pill offers to skip the film entirely. The closing stats say something true (surfaces with live presence, tools your companions can call) instead of counting up to one.

Ask the sketch assistant to turn what's on the canvas into work and it does it — creating the cards on your board with titles, descriptions and the sketch linked back — instead of telling you what you should create. Drawing got two fixes in the same stretch: agent-drawn text was being stored with no size and so painted nothing at all, and a phantom autosave could wipe strokes an agent had just finished making.

Closing a task now returns you to the board you were just on, instead of dropping you into browser history — sometimes onto a blank page. Open a card, close it, and you land right back among your columns, with Back reopening the card if you want another look. It behaves the same whether you opened the task from the board or straight from a shared link.

read_databank_file answers inside the tool result, and MCP hosts quietly truncate those around 45 KB — fine for a config file, useless for a spreadsheet. Its new mirror, create_databank_download, hands the agent a short-lived signed link and a ready-to-run curl command instead, so the raw bytes travel over a normal HTTP download — the whole XLSX, ZIP, or PDF, exactly as stored. The link enforces the same permissions as reading the file in the web app, expires quickly, and always downloads as an attachment rather than rendering in place.

Turn your camera off on a call and your tile no longer goes blank or stretches oddly — your avatar and name tag take its place, so everyone can still see who is who at a glance.

Open a task on a wide screen and its comments now sit in their own column beside the details, giving the group-chat thread room to breathe instead of crowding under the description. On narrower screens it stacks as before. Comment TL;DRs are tighter too — a single glanceable line, with the full text one tap away.

Two new tools let an agent read what is already there: get_task_attachment returns the contents of a file attached to a card, and read_databank_file reads a file item straight from a databank — so an agent can work with documents it did not upload itself. Building subtasks is smoother too: create_task no longer requires a column when you give it a parent.

A column's ⋯ menu gained Clean up: hand the whole column to an auto-agent that reads every card and proposes what to archive, merge, or move on — and you review its plan before anything actually changes. A quick way to take a column that has grown into a junk drawer and get it back under control.

The task tags field now suggests the tags your auto-agents are watching, so handing a card to the right agent is a tap rather than remembering the exact spelling. Start typing to filter, or pick from the agents you have set up.

Each auto-agent run now records what it spent — cost, tokens, and turns — onto its session and as a status comment on the card it worked, so a task carries the price of the work right next to the work. A team's overview page gained a Team auto-agents panel listing every member's agents with their model, watch tags, and per-agent cost, runs, and tokens, plus a workspace-wide total up top.

Hit Retrieve usage on the team overview and each of your agents reports back the Claude account it actually runs on and how much of that subscription is still available — the 5-hour and weekly windows, how full they are, and when they reset. Readings are kept, so the panel opens with the last one (stamped “recorded 2h ago”) before you refresh it, and an account is only ever read by the person who owns it.

An agent run's troubles used to live and die in its transcript. Now every session keeps a record of what it ran into — failed tool calls, timeouts, a tool it needed that didn't exist, runs that hit the turn ceiling — read straight out of the transcript, plus a report_session_friction tool for the kind of gap a transcript can't show. Recurring problems are recognized as the same one (ids, paths, and numbers are normalized away before comparing) and land as a single card on your findings board that counts up each time it's seen again, instead of forty duplicates. Samples are scrubbed of tokens and keys before they reach a team board.

Lead an omnisearch with a type word — sketch onboarding, task migration, board mcp — and it narrows to just that kind and searches the rest of what you typed. Handy when the thing you want shares a name with five other things. A bare keyword on its own still searches everything, so you can't accidentally strand yourself in one category.

Connect several Claude accounts instead of one: label each, mark a default, and rename or disconnect them individually under Settings → Claude. Then pick which subscription a session or an agent profile runs on, so a long stretch of agent work can be spread across accounts instead of burning one to its limit. Re-pasting a token you've already connected updates that account rather than quietly adding a twin.

The auto-agent transcript reads like a timeline now instead of a wall of identical “Bash · Completed” rows. Every folded tool call carries a one-line peek at what it actually did — the command it ran, the file it touched, the pattern it searched, the page it fetched — alongside when it finished and how long it took, with a live indicator while it's still going. Rows are tighter too, so more of a run fits on screen.

Comment threads gained a Simple view: your comments on the right in a bubble, everyone else's on the left with their face, and a burst of consecutive updates from the same author folded into a single stack — so an agent's status chatter stops flooding the card. Long comments show an AI-written TL;DR that expands to the full text, and one press of Backfill TL;DRs fills the whole thread, bubble by bubble. Classic view is one tap away, unchanged.

An auto-agent session bound to a task now appears in that card's Attached area with its status and model, linking straight through to the live console transcript. And clicking a subtask on a board opens it properly instead of dead-ending on “Task is unavailable”.

Calls now hear about disconnects from the media server itself, so a force-quit tab or a laptop that drops off actually leaves the call instead of lingering as a ghost participant. When the last person goes, the call ends on its own and frees the conversation for the next one — no more hunting for End for everyone. Plus: open a sketch while someone else is presenting their screen and you now land on the sketch, instead of being stuck watching their share.

Open omnisearch before typing and it offers Jump to shortcuts — boards, sketches, databanks — instead of a blank list. They follow whichever team you have selected, wearing its color and landing you in that team's content. On a phone the page behind now dims and blurs so the search has your full attention; tap outside to dismiss.

When an agent claimed a card but its session never actually started, the card just sat there looking picked up — the reason lived only in a transcript nobody was watching. Now a failed activation posts a ⚠️ comment on the card naming the cause and how to retry it, so a stalled pickup announces itself. Runner logs also carry timestamps now, which makes reading back what happened far less of an archaeology exercise.

An auto-agent used to begin every task the slow way — clone the repository, then burn its first turn installing dependencies. Each repo now keeps a prepared workspace that new sessions are seeded from by copy, so the agent lands in an installed checkout and gets straight to the work. The console's Repos panel shows each repository's environment as Ready, Building, or Stale, with a Rebuild button when you want a fresh one.

Create named agents that watch the task tags you choose, then tune each one with its own model, effort, standing instructions, and home repository. Add a matching tag to an unblocked card and the agent claims it once, opens a linked Claude session, comments its plan, does the work, and moves the card forward — or explains exactly why it's blocked. Need another pass? Re-arm the pickup right from the card.

Connect a GitHub token in Settings → Repositories and an auto-agent can take a code task all the way through delivery. Link a repository to the card — or give the agent a default — and its fresh session clones the repo, works on a task-specific branch, pushes the change, and opens a pull request that's linked straight back to the card. The token is stored sealed and stays revocable from Settings or GitHub.

Open a card and its shareable URL now uses the compact tsk_ ID instead of a raw UUID — including parent and subtask links — while every old link keeps working. Task details scroll properly on phones even when your finger starts on Markdown, and card-shaped loading states replace the old spinner so opening a task feels faster and steadier.

Connect your own Claude account or API key with the guided setup in Settings → Claude, then start real Claude Code sessions without leaving HardlySimple. Every session gets its own workspace, a live transcript, model and effort controls, and a stop button; switch on Platform MCP and the agent can work your taskboards, sketches, and databanks as you. Sessions run on your Claude subscription, and the connection is yours to disconnect at any time.

Hit Share screen in any call and choose a browser tab, app window, or display. The first share moves onto the main stage automatically; if several people present at once, pick another screen from the filmstrip. Tab or system audio plays when the browser supplies it, and sharing keeps going while the call follows you in picture-in-picture — with a stop button there too.

Agents attaching an XLSX, ZIP, PDF, or other non-trivial file to a task or databank no longer have to squeeze base64 through an MCP tool call. Two new tools return a short-lived signed upload ticket and a ready-to-run curl command, so the raw bytes travel over a normal HTTP upload with the same permissions and validation as the web UI.

Share a file and you see it immediately — a preview thumbnail with a spinner while it uploads, everywhere you attach: team chat, in-call chat, task cards, and databanks, no more wondering whether it went through. Drag-and-drop now works inside a call's chat too, and you can attach HTML files and ZIP archives alongside images, PDFs, and docs — they download safely instead of opening in place.

Task cards can now carry a one-line TL;DR, so you get the gist of a card at a glance without opening it. Open a task and hit Generate TL;DR to have one written from the title and description — Regenerate to refresh it. Agents get it for free too: create a task over MCP without a summary and one is written automatically, with a regenerate_task_summary tool to redo it on demand.

Write a task description in Markdown and it renders properly — headings, lists, checkboxes, tables, code blocks, and links all come through formatted instead of as raw text — while your @-mentions stay highlighted and clickable. It edits in place and round-trips cleanly, so what you write is what your teammates read.

Open a task and hit the new Open in button to hand the whole card straight to your AI — Claude, Claude Code, Codex, or ChatGPT, each under its own logo — launched pre-loaded with the card's title, description, ID, and a link back to it. If the app doesn't open, the prompt lands on your clipboard ready to paste, so kicking off work on a card is one click.

The chat that rides along on a call grew up. @-mention a teammate and they get a notification that links back to the exact message, and you can drop files right into the conversation. Attachments broadcast live to everyone on the call and are saved to the conversation too, so nothing's lost when the call ends.

Team URLs now use a short, readable slug taken from the team's name — /teams/design-research instead of a long raw ID. The slug is fixed when the team is created, so a link you've already shared keeps working even after the team gets renamed.

Calls, live companions, and notifications now push to you the instant they change over a single realtime stream, instead of quietly polling every few seconds for updates that usually hadn't happened yet. Everything that used to lag a beat behind now updates right away — and it's easier on your connection and your battery.

Type @ in a chat, task description, or task comment and a picker pops up with your teammates, plus tasks, sketches, and knowledge bundles from your team. Pick one and it drops in as a chip — teammate mentions highlight, and tasks/sketches/bundles become links you click straight through to. @-mentioning a teammate sends them a notification, so you can actually get someone's attention.

The paperclip and drag-and-drop now take multiple files in one go and share them as a single gallery message. And you can paste an image straight from your clipboard — a macOS screenshot goes from ⌘⇧⌃4 to shared with one ⌘V, in a chat or on a task card. Chat files are tucked into a “Chat files” folder in the team databank so they're easy to find later.

URLs you send in chat — in the team thread and in an in-call chat — or add to a task description or comment now render as real, clickable links that open safely in a new tab, instead of sitting there as plain text.

Click any image — in a chat gallery, on a task card, or in a databank — and it opens in a full-screen lightbox with next/previous, arrow-key navigation, and a link to its databank entry, instead of dumping you onto a raw file URL in a new tab.

Share a live sketch onto the call stage: it fills the screen while the video feeds shrink to a filmstrip, and everyone on the call co-edits the same canvas in real time. Drop named marks on it, then ring a mark's bell to point the whole call at that exact spot — everyone gets a nudge and a tap jumps their view right to it.

A call no longer drops the moment you leave the call page. Navigate anywhere and it shrinks to a floating picture-in-picture — live video, a mute button, and one tap to jump back to full screen — so you can pull up a task or a sketch mid-call without hanging up.

In-call camera controls: a zoom slider on cameras that support it, and a one-tap switch between your front, back, or external cameras.

Start a video or audio call straight from a conversation. A channel call is an open room anyone in the channel can hop into; a direct-message call rings just the two of you. Calls run on our own LiveKit backend, survive a page reload with a return-to-call banner that walks you right back in, and every call has its own shareable link.

A count ball rides your avatar and a dropdown panel keeps you on top of what needs you — a new direct message, or a call starting in one of your channels. It's pushed live over the realtime layer (no refresh), each notification deep-links straight to the conversation, and opening a chat clears its unread for you automatically.

Drag a file onto a conversation — or tap the paperclip — to share it inline. Images preview in the thread, everything else lands as a tidy chip, and a typed message rides along as the caption. Each shared file is also filed into the team databank, so it's browsable later instead of buried in scrollback. Works on your phone too.

A live “…is typing” line appears at the foot of a conversation as your teammates write. It's ephemeral presence over the realtime layer — instant to show, and it leaves nothing behind when they stop.

Teams now have a plan. Premium unlocks team chat and the on-canvas sketch assistant, toggled per team by a platform admin. Existing teams are already on Premium with everything switched on, and personal sketches keep their assistant no matter what.

Every team gets chat — shared channels for the whole team and private one-to-one direct messages. Messages are realtime, the layout folds to a single pane on mobile, and it's the home base that calls, file sharing, and typing indicators all build on.

Click a present collaborator to follow their viewport — your canvas tracks theirs as they pan and zoom, so walking through a sketch together just works. Now on mobile as well, with a dedicated control to pick who you're following.

Tap the ✨ on any sketch and a chat panel morphs open: say what you want and the assistant draws it straight onto the live canvas — shapes, node-and-edge diagrams, arrows, labels, color and fill — reading what's already there so it builds on your work instead of over it. It follows your team's design system when there is one, keeps a clean look when there isn't, and every stroke is attributed to the companion (and model) that drew it.

Taskboards, tasks, and sketches now carry compact, readable IDs — tb_, tsk_, and sk_ prefixes — in their URLs instead of long raw UUIDs. They use a no-confusion alphabet (no look-alike 0/O or 1/l), so a link is easier to read, share, and paste, while the canonical UUIDs keep doing the heavy lifting behind the scenes.

Sketches now open locked by default, so you can pan, zoom, and read without nudging a single shape — flip to Editable when you actually want to change something. On mobile the controls moved to a tidy bottom bar: a Marks popover to jump between named points, the lock toggle, and omnisearch pinned to the top, with the assistant a tap away just above it.

The sketches sidebar stops being one long flat list: group sketches into folders by dragging them in and out, tag them and filter by tag, and pin the important ones to the top. The no-selection landing now greets you with your most recent sketches as live preview cards, so you can pick up where you left off in a click.

See collaborators on the canvas as avatar cursors — each arrow carries the person's (or agent's) face and name, tracking in real time. Under the hood autosave got airtight: no phantom saves on load, no lost elements when you rename, and a flush that survives you navigating away — so the next time you open a sketch it's exactly as you left it.

New Repositories: point the workspace at a git remote (intake_repository over MCP, or the Settings → Repositories page) and cards that link commits, PRs, and branches resolve to real GitHub/GitLab URLs. Keep a repo personal, or connect it to a team so those links — and its board, knowledge, and sketch defaults — work for every member. A fresh /getstarted walks an agent through connecting over MCP and binding the repo via one .hardlysimple/config.json.

The admin team page can now mint invite links, so a manager can bring in someone who doesn't have an account yet — they land as a pending join request you approve right there, and platform admins can invite and verify on any team. Add-member search was also tightened to exact-email lookups, so it can't be used to enumerate the user directory.

Companion sessions now start themselves the moment an agent acts, wind down on their own once they go idle, and each avatar wears a countdown ring showing how long until it times out — so “who's working right now” is always honest, never a stale ghost. Every session also gets its own page with the full, ordered trail of what that agent did.

The open task card folds files, images, sketches, knowledge bundles, tables, and linked code into a single “Attached” list behind one “Add” menu — no more a separate stacked section per type. Images keep their thumbnail grid and cover star; everything else reads as a clean chip, and new link types just slot in.

Agent payloads slimmed down across the board: tool results ship compact JSON, mutations reply with just what changed instead of echoing the whole board, and list_tasks gained newest-first ordering with cursor pagination and an “updated since” filter — so agents page through what changed instead of re-reading everything. Same data, a fraction of the tokens.

The web view stopped being read-only-and-that's-it: tables now sort by any column, search across their records, and paginate — and the view lives in the URL, so a sorted, filtered, page-three table is a link you can send someone. Tables also link to task cards in both directions, so the data behind a piece of work sits on the card instead of in someone's memory.

Tap the lightning button (or hit ⌘K) and a search bar slides out: type to jump to anything across the workspace — tasks, boards, knowledge, databanks, sketches, tables, and teams — with typo-tolerant fuzzy matching, grouped by type. Teams and boards surface first, every result wears its team's color, your current team's hits are prioritized, and opening a result in another team switches you into it.

search_tasks and search_knowledge give agents relevance-ranked, snippet-bearing results across boards and knowledge bundles — full-text and semantic, fused — so they land on the right card or passage instead of paging whole boards or reading whole documents.

Break a card into subtasks: drag one card onto another to nest it (one level deep), then open a card's own detail page to see its parent, add or detach children, and work through them. Cards show their subtasks as slim lines, archiving a parent tucks its children away too, and agents can build the hierarchy over MCP — create_task, update_task, or move_task with parentTaskId.

A task card can now point at the code that implements it — commits, pull requests, or branches — linked over MCP (link_commit) or by the /implement loop. Cards show a commit/merge chip, so "is this done card actually shipped?" is a lookup instead of a repo grep. Plus bulk create_concepts / add_sketch_marks to cut agent round-trips.

Databank items now live in folders you can drag them in and out of, carry colored tags you can filter by, and show who created each one — you, or an AI companion (with its brand). Agents can organize over MCP too: create_databank_folder, move_databank_item, and update_databank_item.

Agents can now build SimpleTable workspaces of typed tables and validated records — text, numbers, single/multi-selects, dates, emails, and more — then bulk-insert, search, and filter them over MCP (no raw SQL). Each workspace slots into a databank alongside your other work, with a read-only web view to browse it.

New /admin/realtime and per-team activity views to watch what's happening across the workspace, live.

/plan, /implement, and /help prompts guide agents through the work — plus a request_human_review tool to loop a person in when it matters.

Create many tasks in one call, provision tasks inline, move a board to a team, and delete taskboards.

upload_task_file and upload_databank_file now accept a data URL or a plain link the server fetches — so agents can attach real screenshots, not just tiny inline blobs.

Shared databank containers with a web UI, live presence, and direct agent uploads — a proper home for the files your agents work with.

upload_task_file landed: an agent can drop an image or document straight onto a task card, served through the same-origin media proxy.

See who — human or agent — is in a board, sketch, or databank in real time, with “who touched this” fingerprints and a global live indicator.

Drop comments on any card. Agents post status and attention updates that show up live on the board.

Name points on the canvas, click to deselect, and move sketches to a team — with team-scoped presence.

Column control (move, rename, delete), agent-visible prompts, and team-visible taskboards.

A teams overview, shareable invite links, and assigning people — or agents — to tasks.

/admin/users for super-admins, an audit trail across users and companions, and OAuth sign-in for a real product feel.

/get-mcp ships a one-command installer and connector details, so any agent connects in seconds.

New personal and dashboard views, realtime taskboards, and cleaner dark mode and avatars.