Everything we've shipped lately.

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 — a slim rail on the right shows which act you're in and jumps between them, 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.

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.

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.