What changed, and when

This release covers four versions of work (14.18 through 14.21) that hadn't shipped yet.

The headline is how delegated work now behaves. When the agent hands a coding job to a

sub-agent, that sub-agent no longer writes anything: its edits come back as a proposal per

file, and the main agent reads each diff and decides. Accepting writes the sub-agent's exact

work — nothing is retyped along the way — and a file that isn't already on your allow-list

still asks you, exactly as it would for any other edit.

Sub-agents are also visible now. A long one moves to the background on its own instead of

holding the turn, and the running-tasks chip lists them alongside background commands, so you

can watch progress or stop one without waiting.

• Delegated code changes are reviewed before they land. Previously a sub-agent worked in a

hidden copy of your project and handed back one big diff, truncated if it was long. Now each

file arrives separately with its own diff. If two sub-agents changed different parts of the

same file, both can be accepted; if they changed the *same* lines, that is flagged as a

conflict rather than silently resolved.

• If a file changes while a proposal is waiting, the change is re-fitted onto your newer

version when it still fits, and refused with an explanation when it doesn't — it will not

overwrite work you did in the meantime.

• Sub-agents appear in the running-tasks chip, with elapsed time, live progress you can

expand, and a stop button. They were previously invisible there and could only be stopped

from inside the agent's own turn.

• A sub-agent taking more than 30 seconds moves to the background automatically, so the

turn keeps going. A foreground sub-agent previously had no time limit at all, which is why

one occasionally looked stuck. One that goes quiet for a long time now nudges the agent

instead of stalling silently.

• Sub-agents can be referred to by name, not just an id — the same as background jobs.
• Delegated work in Plan mode can now fan out across subsystems and web research instead

of being limited to a single helper.

• Each window is its own workspace. Windows are named after the project they have open,

and a window's browser tabs, terminal tabs, and plan cards belong to that window alone —

they no longer leak into another one.

• The agent can send a command to a named terminal tab and read one back, instead of

opening a new tab each time.

• Writer sub-agents no longer need a git repository. In a project that isn't tracked by

git they previously ran read-only without saying so clearly. They also see files git

ignores, which they could not before.

• Fewer, clearer tools. terminal_read/terminal_list folded back into background jobs;

listing and stopping sub-agents moved to its own tool.

• Automations lost the "worktree writes" mode. Existing automations set to it become

read-only runs. Nothing else about automations changes.

• The disk space a removed feature left behind is reclaimed on first launch.

• Background work no longer dies with "Core has an issue." Resuming a turn after a

background task finished could fail outright on some models.

• Older messages are no longer silently deleted from a long conversation. The turn history

was being trimmed without telling you or the model; now it isn't trimmed, and the model is

told its actual context size rather than guessing.

• A long session no longer breaks partway through because the sign-in token used for

Atlarix Core had gone stale mid-stream.

• A 1,000-line edit no longer freezes the app for several seconds. The diff is now

computed before it reaches the screen, and a very large one starts collapsed with a summary.

• The token counter survives a restart and updates when you switch work mode.
• A plan step that fails to tick is now recorded, and a plan can no longer be marked

complete when it never started — the cause of a spurious "18/18".

• Renaming a session by editing your first message now works; a name you typed yourself is

still never overwritten.

• A fast model now streams its answer instead of just appearing. Some providers reply

quickly enough that the whole answer landed in one step — the text never streamed, and the

view jumped to the bottom in a single jolt. Replies are now revealed at a steady rate, so

reading one feels the same whichever model you picked. Models that were already comfortable

to read are untouched: the limit only applies to output arriving faster than that, so

nothing has been slowed down to achieve it. If you have reduced motion enabled, text

appears immediately as before.

• A custom credit top-up below the $10 minimum is now refused as you enter it, with the

reason, instead of being added to your running total and then rejected at checkout.

• The app is much quieter on the network while idle. A one-time account setup step was

being re-requested on every session check, once for each part of the app that asks who you

are — dozens of identical requests for something that can only happen once. Requests that

overlap are now answered together. Nothing about your balance or plan is cached, so a

top-up still shows up straight away.

Core used to reach every managed model through OpenRouter. It now calls the provider APIs

directly, which is why the model list is shorter and sharper: GLM 5.2 and **DeepSeek V4

Pro**, both with a one-million-token context. One prepaid balance still covers all of them —

you are billed what a reply actually costs on the model you used, so switching mid-conversation

is fine.

• Your answer no longer ends up inside the "Thoughts" card. Every model that wraps its

reasoning in <think> tags — DeepSeek included — was having the visible reply captured as

part of its thinking, so reasoning and answer appeared mixed together. A reply that *opened*

with reasoning could vanish entirely. Four separate places normalised those tags the same

wrong way; they now share one implementation, so they cannot drift apart again.

• A stray `</think>` no longer appears in the middle of a reply. Some models send the

closing tag on its own; it had nothing to match against and was rendered as text.

• Atlarix Core now knows how big its models really are. Core was reading its context window

from the wrong catalog and falling back to 128K — so a million-token model was being compacted

at roughly an eighth of its real capacity, throwing away context that never needed to go.

DeepSeek on Core now resolves its true ~1M window.

• Thinking settings reach the model in the shape it actually accepts. Reasoning options were

picked per *provider*, so every model from a given provider got the same request — which is why

MiniMax M3's thinking behaved oddly while its sibling looked fine. Each model's own declared

capability is now used, and a model is never sent an effort level it does not support.

• Models that reject a `temperature` setting are no longer sent one (Kimi K3 among them).
• Citations link to pages, not to raw source files. Web search kept surfacing code files,

which crowded out the articles and docs that answered the question. The citation preview also

showed a blank panel; it now shows the search excerpt, with buttons to open the page in

Atlarix's own browser tab or externally.

• Discord profile pictures load, and the account badge says Discord instead of GitHub.

• The token meter names what background work spent your tokens. Sub-agents and context

compaction were shown as a single figure labelled "Sub-agents", so work the app did on your

behalf looked like work you had asked for. Each source is now listed separately with its call

count.

• The agent knows where it is on a page. Reading a page now reports scroll position, so it

scrolls to find content that only loads further down instead of concluding it is absent.

• The Core model list follows the catalog. Atlarix can run two, three or four Core models and

the picker shows exactly what is configured — no placeholder rows for slots that are empty.

• Core web search now uses the built-in search tool and the in-app browser. OpenRouter's

server-side search is not available to Core any more, and none of the direct providers offers an

equivalent over a plain chat endpoint. A dedicated search integration is planned.

• A Core model that is temporarily unavailable says so plainly and points you at the other

Core models or your own API key, rather than implying all of Core is down.

• You stay signed in across restarts. v14.16.0 moved the startup session restore to *after* the window appears — the change that stopped the app hanging for minutes on a bad network. The renderer therefore starts signed-out and is corrected once the session lands, but the handler receiving that correction could only ever *update* an existing signed-in state, never establish one. So the correction was dropped and you were asked to sign in again, with a perfectly valid session sitting in the app the whole time. It now re-reads the session from the main process rather than trusting the notification, which carries plan details but no identity. A second fault with the same effect is fixed too: the user's identity was only recorded *after* their plan had been looked up, so a failed lookup — exactly what happens offline — discarded the session.
• A provider's models appear the moment you save its API key. Model lists are cached for five minutes and were only refreshed by a few specific events; saving a key wasn't one of them. Add a key and the model picker kept showing the list from before it existed, so a provider you'd just set up looked missing — and deleting a key left its models behind. Fixed at the single point every provider form writes through, so it holds for every provider and any added later. No keys were ever lost — only the display was stale.
• Onboarding text no longer refers to Blueprint and Code-to-Canvas, both removed some releases ago.

• Sign in with Discord, alongside Google and GitHub. If an account doesn't share a verified email address, sign-in now stops with an explanation instead of creating a half-account that can't be plan-checked or billed.
• Settings → Community — join the Discord, review Atlarix on PeerPush, and a one-time "where did you hear about Atlarix?" question. The download of an installer carries no trace of the post, video or person that sent you here, so it's the one thing analytics genuinely cannot answer. Asked at most once per account, skippable, and always available in Settings if you'd rather answer later. It respects the analytics opt-out.

• The browser agent grew the ergonomics it was missing — several tabs at once, find-an-element by description, and the ability to press a key, hover, or scroll. It could not previously press Enter.
• The app opens without a network, in the time it takes to draw a window.
• The models.dev catalog is now the floor under every provider, so a truncated /models response can no longer make models disappear from the picker.
• Dictation, voice settings and analytics identity corrected.

• The browser agent can keep several pages open. New browser_tabs (list/create/switch/close) exposes the tab lifecycle. Previously every navigation reused the one tab, so opening a second page destroyed the first one's state.
• `browser_find` — locate an element by describing it ("login button", "search box") instead of reading the whole page first. Ranked heuristically in the page on role, accessible name and text: no model call, so it's deterministic, free and instant.
• `browser_interact` gained `key`, `hover` and `scroll`, plus typed fill. The agent could not previously press Enter — no submitting a search box, no Escape to close a modal, no Tab between fields.
• `browser_batch` — run several predictable steps in one call (fill, fill, press Enter).

• The agent's cursor is visible while it works. A pointer now glides to each target and stays on screen between actions, with a ring on the target and a chip naming what it did.
• The Browser panel opens the way the Plan panel does. When the agent needs the browser it asks the UI to open the right panel on its Browser tab, honouring your auto-open preference.

• Browser session recordings (the frame-by-frame replay). Watching the agent live is now better served by the visible cursor and the panel following along, and the ordered text record of what it did is kept.

• Screenshots work with the Browser panel closed.
• Element refs no longer shift under the agent. Refs are now held in a WeakMap keyed on the element itself, so a ref means the same element for the life of the document.
• Reads disclose the viewport they were measured at.
• Truncated reads report the real total. "capped at 200" now says "showing 200 of 1,340".
• The app no longer hangs at launch without a network.

• No more separate Preview tab — your app just runs in the browser. Open your dev server's URL in the

built-in Browser tab and the agent drives it (or you do) to see and test your app as you build. One

surface to learn instead of two.

• Errors you can act on. The Errors tab now shows real stack traces — browser console errors,

uncaught crashes, and failed network requests — so the agent can see exactly what broke at runtime and

fix it. Click a localhost:3000 link anywhere in chat or the terminal to open it in a browser tab.

• See (and adjust) the wait. Background jobs can now show a live countdown — how long until the agent

checks back — and it clears itself when the job finishes, so timers never pile up.

• Installs just work. Tools like yarn no longer fail on first run inside the sandbox, and when a

command needs to write somewhere new, Atlarix asks once and keeps going — still sandboxed.

• Quieter and smoother. Less idle background chatter, new keyboard shortcuts, and a fix for code

blocks that could spill outside their box.

• Web search for Core models. DeepSeek, Qwen, Kimi, and MiniMax can now search the web when a

question needs current information — metered through your Core credit wallet, no setup and no API key.

• Work across repos. The agent can now read and edit files *outside* your open project — an upstream

dependency, a sibling repo — instead of being walled in. Reads just work; every outside edit still waits

for your approval with a diff.

• Steadier under pressure. A full disk no longer freezes a turn — the app degrades gracefully and

tells you instead of stalling.

• Lighter and snappier. Leaner agent prompting and a trimmed dependency tree.

• Updates now download and install. Fixed the bug where an update could get stuck on "Downloading…"

and never offer to restart — auto-update now works on macOS, Linux, and Windows.

• One-time note: if you're on an older version, you'll need to do a single manual update to this

version (download it from the site). After that, future updates install automatically.

• Atlarix Core shows its real models. The Atlarix Core provider page now lists the actual models

you're using (Kimi, Qwen, DeepSeek, MiniMax) and reads "Setup Complete" — no API key needed.

• Simpler provider setup. Cleaner wording when connecting your own providers, and a single,

straightforward model picker for local runtimes (Ollama, LM Studio).

• Snappier model list. The list of available models loads faster and no longer rebuilds itself

every time you open a screen.

• More reliable auto-updates. Fixed an issue where an update could get stuck on "Downloading"

instead of finishing and offering to restart.

• Better-looking tables and code. Replies with tables that reference code no longer break into

stray rows, and inline code snippets render cleanly — Atlarix now keeps multi-line code in proper

code blocks instead of squeezing it into a table cell.

• Tidier command and tool output. Command results, web searches, and other tool output now show

just the content — the internal safety markers Atlarix uses behind the scenes are no longer

displayed in the chat.

• Clearer wallet message. If a refund leaves your Atlarix Core balance negative, the balance now

explains why and prompts you to top up before using Core again.

• Atlarix credits you as the author, not itself. When Atlarix helps you commit, your own name and email stay on the commit and Atlarix is added underneath as a co-author (the standard Co-authored-by: line) — the industry-standard approach. (On a machine with no git identity set up at all, Atlarix still signs the commit so it doesn't fail.)
• The "add Atlarix as co-author" switch now fully works. Turning it off removes the co-author line everywhere, including commits the agent makes in the terminal — previously it could still slip in.
• Cleaner, better-formatted replies. Every model is now told your chat renders as markdown, so answers come back with proper headings, lists, tables, and code blocks.

• Real model prices in the picker. Instead of a flat "Free", each model now shows its actual cost per million tokens, pulled from a live catalog (and directly from OpenRouter for your own key). Local models stay free.
• Smarter file edits. Atlarix can now apply several edits to a file in one atomic step, and understands a "here's the new shape, keep the rest" style with // ... existing code ... markers — so edits are more reliable and refuse rather than corrupt when something doesn't line up.
• A smoother, calmer harness. Big pastes no longer freeze the app, the live token counter keeps working with the usage panel closed, sending an image to a text-only model gives a friendly "switch to a vision model" note instead of an error, and quiet long-running builds are left to finish instead of being nudged to cancel.
• Security hardening. Stronger protection for stored keys when no system keychain is available, and tighter validation on privileged internal actions.

• Simpler pricing: Free + Pro, and Atlarix Core is pay-as-you-go. No plan bundles AI anymore. Atlarix Core runs on a prepaid credit balance you top up (from $10) and spend as you go — the same on Free and Pro. Every new account gets a $1 trial credit to try it. BYOK and local models stay free on every plan. (The old Team tier is gone — its one-click connectors are now part of Pro.)
• Talk to Atlarix. New built-in voice-to-text: dictate to the chat instead of typing. It runs on-device with local Whisper by default — free and private, no key — or bring your own OpenAI, Groq, or Gemini key for cloud accuracy (that never touches your Core credits).
• Automations. Schedule the agent to run unattended — on a cron, a GitHub event, or an MCP trigger — from the Automations tab, with a feed of past runs. Two per workspace on Free, ten on Pro.
• See your live usage. A running token counter shows real provider usage as a reply streams — for the main agent and each sub-agent.
• Fewer duplicate attachments. Attachments are de-duplicated by content, so pasting or attaching the same file twice no longer sends it twice.

• Commands just run — safely. Atlarix no longer second-guesses everyday commands with rigid rules that sometimes blocked perfectly safe ones (like fetching from git or building a project). In read-only modes your files are protected by a real operating-system sandbox, so commands can look around freely but can't change your code; in Build and Debug they run normally. Genuinely risky actions (deleting, sudo, piping the web into a shell) still ask first.
• Smoother, cooler long answers. Long conversations and long streaming replies now stay light on your machine — the chat only renders what's on screen, re-parses just the part that's still being written, and cleans up old leftover index files (freeing over a gigabyte on some setups). Less heat, less lag, during big sessions.
• Resume looks right again. When a reply is interrupted and you hit Continue, it now picks up seamlessly instead of showing a stray "continue" message as if you'd typed it.
• "Jump to latest" goes where the writing is. Tapping it during a streaming reply now lands you at the live edge where new text is appearing, not partway up the message.
• Sharper, more trustworthy code changes. Under the hood, Atlarix now holds itself to stricter habits when it writes tests and fixes — proving a test actually catches the bug before trusting it, and reusing what your project already has instead of reinventing it.

• Code search is now fully self-contained. Atlarix bundles its own fast search engine, so finding files and searching your code works on every machine with nothing to install — no setup, no "command not found."

• Much lighter and cooler on big repos. Atlarix no longer keeps a background index or file watcher running — it searches your code directly with bundled ripgrep. On huge projects that means no more machine heating up, no runaway file usage, and no slowdowns in long sessions. It just stays fast and quiet.
• Connect almost any AI provider. The provider list now includes every provider the community catalog knows about — 150+ — so you can drop in a key for whichever service you use and its live models (with their real context limits) show up automatically. No app update needed when a provider adds a model.
• See what each sub-agent costs. When Atlarix delegates work to sub-agents, each one now shows its own token usage right on its card, on top of the running session total.
• Tidier AI terminal. Background commands the AI runs now clean up their own tab once they finish successfully, so the terminal stops piling up tabs — while failures and long-running servers stay put for you to check.

• Your Core key never touches the app. Atlarix Core now runs through a secure hosted gateway. The managed model key lives only on our servers — it's no longer inside the app on your machine — and your monthly usage is checked and counted server-side. Nothing about how you use Core changes; it's just safer.
• No account secrets shipped in the app. Billing and email actions (upgrading, cancelling, team invites) now happen through secure server endpoints signed in as you, so no sensitive keys are bundled into the download.
• Stronger account & team protection. Hardened the rules behind plans and teams so entitlements can't be tampered with, and tightened how subscription events are matched to your account.

• Faster, cooler on big repos. Atlarix now uses a smarter, native file watcher that ignores everything your .gitignore already ignores (node_modules, build output, caches) — so opening a huge project like VS Code no longer floods your machine with work. First searches are quicker too, and long sessions stay lighter on memory.
• Smarter command approvals. Read-only commands like ls, grep, find, cat — and pipelines of them (ls | grep) — just run, in every mode, without a prompt. Anything that could write, delete, or reach the network still asks. And once you "always allow" a tool (say npm), it now works even inside chained commands. You can see and turn off the built-in auto-run list in Settings → Terminal permissions.
• Paste works from anywhere. Pasting a long prompt now becomes a tidy attachment chip even when you copy from Notes, TextEdit, or a word processor — not just from a code editor.
• One "done" sound, not two. Finishing a task now plays a single notification instead of doubling up.
• Long chats stay snappy. Very long conversations render only the latest messages (with a "Show earlier" button), and scrolling up while a reply streams no longer fights you.
• Security hardening across command handling, links, and file access.

*July 2026*

• Attachments read whole — and survive everything. Files you attach are never silently cut

short: the assistant pages through the FULL content of big PDFs, spreadsheets, and documents

(.py, .go, and every code file now previews too). Attachments keep working after you edit a

message, stop a reply midway, or restart the app — and each conversation only sees its own

attachments.

• Vision models actually see your images. Attach a screenshot or photo and a vision-capable

model receives the real picture right in your message — no roundabout steps. Models that can't

see images now say so plainly instead of confidently describing an image they never saw.

• Edits that never corrupt indentation. The file-edit tool re-anchors changes to your file's

real indentation (tabs stay tabs) even when the model drifted — the live bug where a Go file

came back with mangled whitespace is gone, verified by the model that hit it.

• Honest context numbers everywhere. The "compress context" action now actually frees space

when the assistant asks, its banner tells the truth, and every model gets its REAL context

window from live catalogs — a 1M-token model is no longer treated as 128K, so long sessions

compact ~8× less often.

• Replies read in true order. Helper-agent cards now flow thought → action → thought like the

main chat, compaction cards sit where they happened instead of sticking to the bottom, and

editing a message keeps its attachment chips visible.

• Snappier turn starts. Drag-and-drop files no longer delay the reply (heavy parsing moved

off the send path), and repeated-history token counting is near-instant — long sessions start

responding noticeably faster.

*July 2026*

• Background work you can trust — and watch. The assistant now reliably receives results from background commands and helper agents the moment they finish (no more re-checking loops), can be woken by a watch-word in a job's output (e.g. "compiled successfully"), and you can expand any running background task in the chat to watch its live output, send it to chat, or cancel it.
• One approvals flow for risky commands. Force-pushes, rm -rf, and other dangerous commands now go through the same allow / always-allow / deny flow as everything else — clearly marked with a warning badge and never run silently. No more dead ends where the assistant couldn't proceed; "always allow" is revocable in Settings.
• Thinks as deeply as each model allows. Reasoning depth is now derived from each model's own capabilities — everyday replies think harder by default, and Deep Think pushes to the model's maximum.
• No more cut-off or repeated work. Fixed a guard that could cut off legitimate multi-step editing mid-task; a genuinely stuck assistant now gets corrective guidance first (a hard stop only as a last resort), finished work is never re-run, and plans can't hijack a session after they're presented.
• Sturdier edits and search. File edits self-heal across curly-quote/dash typography differences, and code search stays fresh with the session's own edits instead of ranking them last.
• UI fixes. Chat no longer freezes when you switch models after a rate-limit error; the sidebar "new window" button opens a fresh window with the workspace chooser; finished replies keep their step cards in place; stray tool text no longer leaks into messages.
• Credit where due. Commits the assistant makes are now consistently co-authored by atlarix-agent.

*July 2026*

• Finishes the whole job. Give Atlarix a multi-step task and it now tracks its plan as a live checklist, verifies each step before moving on, and keeps going until everything is done — instead of stopping halfway. It still pauses when it genuinely needs you (a decision or a manual test) or has background work running.
• Sees your pages more clearly and cheaply. When you ask what a page looks like, Atlarix reads it as a compact text description instead of an expensive screenshot — and it no longer cries wolf about "layout bugs" that are really just intentional background/decorative layers.
• Faster, safer edits. File edits are more robust — surgical replacements self-heal small mismatches, and garbled content is auto-repaired instead of corrupting a file.
• Instant stop. Cancelling a running task now stops immediately, including the background work that used to keep your fan spinning.
• Sharper, less noisy guidance. A broad tune-up of how the assistant is instructed — clearer tool choices, fewer contradictions — so open-weight models (DeepSeek, Qwen, Kimi, MiniMax) behave like they know your codebase.

---

*June 2026*

• Atlarix tests the app it builds — no clicking required. A new headless preview test drives your running web app (open routes, fill forms, click, assert) and won't call the work "done" while the page is throwing runtime errors or failing requests.
• Smoother streaming. The chat no longer jumps back to an earlier spot mid-response or at the end of a reply — it stays pinned where you'd expect.
• No more redoing work after a long pause. When a reasoning model thinks silently for a long time, Atlarix now resumes from where it left off instead of restarting the task.
• Cleaner long conversations. Removed a redundant rolling summary that could make the model act like it forgot earlier messages; it now relies on the full conversation.

---

*June 2026*

• The agent waits like it should. When Atlarix needs your approval for an edit or command, the turn now genuinely pauses on you — the Stop button stays, and it won't claim it's "all done" while it's actually waiting. Approve and it continues the same turn; deny and it carries on; Stop cancels cleanly.
• Start long work and keep chatting. Kick off background commands or sub-agents and the turn ends and hands control back to you — then resumes on its own when the work finishes. No more sitting on a spinner while a 10-minute job runs.
• It manages its own background work. Atlarix can list, watch the live progress of, and cancel its own running sub-agents — and finished results are delivered back to it reliably, so nothing gets dropped (a big reliability win for open-weight models).
• Schedule a re-check. For things nothing can notify it about — a deploy, a remote queue — the agent can schedule itself to wake up and check back later.
• Faster, leaner turns. A loop fix removes a wasted extra round at the end of every tool-using turn — every model spends fewer tokens and finishes sooner. Sub-agent timeouts and "looks stuck" thresholds were also loosened so slow networks and large repos aren't misread as hung.
• Fixes: the context meter now drops right after compaction (and reopened sessions stay compacted); Settings permission rules now actually apply; the "Keep / Revert files" dialog returns after a relaunch; and the agent no longer re-answers a question it already answered while waiting on background work.

---

*June 2026*

• Steadier on long tasks: a brief hiccup mid-reply now quietly retries instead of stopping the whole turn, so long runs hold together.
• "Reconnecting…" only when it's real: that message now appears only when the connection genuinely drops — slow thinking, a long command, or background helpers just read as "still working." (Works the same across every model provider.)
• Your whole chat is there: the entire conversation now loads and scrolls — no more cap on how many exchanges show, and nothing gets quietly trimmed away.
• An accurate context meter: the usage meter now shows what's actually being sent to the model, so it drops back down after the chat compacts instead of looking stuck near full.
• Cleaner streaming: replies render more smoothly as they come in — no flicker or jumping while you scroll.
• Edit & re-run can undo file changes: when you edit an earlier message and resend, Atlarix can offer to undo the file changes from the parts you replaced, so a re-run starts clean.
• Review gives you a list: Review mode stays read-only and hands you a clear list of changes to make, rather than trying to edit anything itself.
• Commands show in the Terminal: the assistant's commands now reliably appear in the right-panel Terminal tab so you can watch them run.

---

*June 2026*

• Watch it use your live app: the assistant can now open, click, and fill in your running app's preview — not just a browser tab — so it can try a feature the way you would and check that it actually works. You see it happen right in the chat.
• A replay of what it did: when the assistant works through your app, you get a scrubbable recording you can scroll back and forth through — no more jumping straight to the last frame.
• Long jobs keep running: dev servers and slow builds no longer get cut off — anything still going after a few seconds quietly moves to the background, keeps running, and the assistant picks back up automatically when it finishes. You can see and stop background jobs anytime.
• Your preview just loads: start your app and its address loads into the preview on its own — nothing to wire up.
• Everyday commands just run: routine commands (listing files, checking status, running tests, installing packages, starting a dev server) run freely, while anything that changes your code or git history waits for Build or Debug mode — and genuinely risky commands still ask first.
• Bring more of your own models: any model that supports images can now receive screenshots, not just a fixed few — plus a fix for a Grok/OpenRouter web-search error.
• Clearer tool activity and tidier help: the assistant's actions read more clearly in chat, and the in-app help pages are cleaner.