Skip to content

Changelog

What's new in Coframe Agent: every feature, improvement and fix, dated the day it reached production. Last shipped · 164 releases so far.

October 2026

Fixed

Pin references stay chips after the agent cites your message

A message that referenced pins with {pin:<id>} — for example an Ideas Lab brief sent from Jarvis — lost its pin chips as soon as the agent cited phrases from that message as requirement sources: the highlighted excerpts replaced the whole message text, and the references showed as raw {pin:…} markers with no “Pin N” label.

Both decorations now render together. Each {pin:<id>} still becomes the <comment> · Pin N chip with the same number the page and sidebar show, and the cited phrases around it keep their highlight.

Fixed

Desktop Playwright tests failed instantly on sites with __Host-/__Secure- cookies

On sites such as dropbox.com and dropboxsign.com, every desktop test failed in under a second with browser seed: … Invalid cookie fields before its first step ran, while the same tests passed on real phones and tablets. The test browser inherits the session browser’s cookies for the target site, and cookies whose names start with __Host- or __Secure- were handed over without the Secure flag those names require, so Chromium rejected the whole set. Those cookies are now passed on correctly, and if a site ever sets a cookie the test browser still refuses, only that cookie is left out — with the reason in the test output — instead of the whole test failing.

Improved

Pins a sub-agent reports back now appear in your session

When the agent delegates work to sub-agents and one of them annotates the page, the pins its result points to now show up in your session’s Annotations panel and on the live view the moment the agent reads that result — under the same ids the sub-agent reported, with the sub-agent named as their source. You can open, reply to and resolve them like any other agent pin, and the agent can look them up by id as its own.

Improved

Session status names each sub-agent

agent/status.delegation.children now carries each sub-agent’s name — the role label the parent gave it when it delegated (for example researcher or the research unit it owns) — next to its spawnId, childSessionId and state. Integrations that show delegation progress can label sub-agents by what they are doing instead of by session id. Children spawned without a name are reported as before, without the field.

New

Refer to a specific annotation inline with {pin:<id>}

When you or a connected tool (Jarvis, the API, MCP) send Mark-17 a message with annotations attached, the text can now point at a specific one right where it matters — “Hypothesis: {pin:ann_…} should be larger” — using the annotation’s id. In the chat transcript each reference shows up as a chip with the annotation’s label and the same pin number you see on the page and in the sidebar; Mark-17 is told which record each reference names so it looks at the right one. A reference to an annotation the message does not attach (and the session does not already hold) is rejected up front instead of silently ignored. Messages without references look and behave exactly as before.

Fixed

Sub-agent results no longer disappear when they are large

The parent now receives a sub-agent’s complete corrected result even when it is too large to display inline. A successful correction no longer appears as an earlier rejection or a missing result.

Completion callbacks keep the result selected when the run ended and retry if its saved content is temporarily unavailable.

Improved

Mark-17's questions and updates are easier to understand

When Mark-17 asks you a question or reports progress, it now writes for someone who isn’t an engineer: short sentences, plain words, and no internal codes or test jargon. Every question also comes with one recommended answer and the reason it is recommended, so you can decide quickly.

New

Hide a tool from the agent only while nobody is watching the session

POST /api/session (and /api/variants) accepts a third key in tools: externalTurnExclude. Tools listed there are removed from the agent only on turns that nobody started from the session page — the API-started first turn, messages injected through the agent API, and the agent’s own continuations. The moment a person opens the session and types a message, those tools are back. The typical use is { "tools": { "externalTurnExclude": ["elicit_user_input"] } } for a session launched headlessly: the first turn cannot stop to ask a question, but when someone later picks the session up in the editor the agent can ask them to confirm before it proceeds. exclude keeps its session-wide meaning, sub-agents inherit the new key like the rest of tools (their turns are never a person’s, so for them it behaves like exclude), and sessions that do not send the key behave exactly as before.

New

Choose how many sub-agents and sub-agent browsers a session may run at once

Sessions created through the API can now set their own sub-agent concurrency: send delegation: { maxLiveChildren, maxLiveBrowsers } next to subAgents: true when creating the session. The deployment’s limits stay the ceiling — a request above them is rejected up front with a message naming the limit, rather than silently lowered — and the caps a session runs under are shown in its status as delegation.maxLiveChildren / delegation.maxLiveBrowsers.

The default number of sub-agents that may hold their own browser at the same time goes from 2 to 4, so a session that fans out to four browser sub-agents no longer waits for two of them to finish first.

Fixed

Structured results wait for active sub-agents

Structured results no longer appear ready while delegated research is still running or its completed or failed result remains unread. The parent reads or explicitly discards that work before producing the result, including when a sub-agent finishes during the parent’s final step.

Delayed notifications for results the parent already read or discarded no longer restart it after it finishes.

Fixed

Sub-agents use the same Jarvis and the same tool policy as the session that spawned them

A session created through POST /api/session with subAgents: true now hands its sub-agents its own setup: the Jarvis pinned with mcpServers.jarvis.url, any other mcpServers (with their headers), the tools include/exclude policy and capabilities. Before, a sub-agent fell back to the deployment’s default Jarvis and the full tool surface, so a session launched from a Jarvis preview could get research from children talking to production Jarvis with tools the caller had excluded. A sub-agent of an outputSchema session keeps that session’s analysis-only tool profile but not the outputSchema itself — its result still comes back through submit_result — and it does not receive the session’s systemPrompt: a sub-agent’s instructions are the objective it was spawned with. Sessions without sub-agents, and callers that never set these fields, behave exactly as before.

Improved

Published cards in chat say less and show more

Both places a publish shows up in the chat are now one line each: Published, the time, who published, and a preview link per variant named the way Jarvis names it — V1 Flash Deal, V2 Hero Refresh. Gone are the publish_variant tool tag, the “live in Jarvis” chip, the repeated build names and the raw variant ids. A failed publish reads Publish failed with the error on the next line; the source revision moved into the time’s tooltip. Expanding the agent’s card still shows each destination’s preview URL, the duration and the raw JSON.

New

Scope requirements to specific experiment variants

Mark-17 can now record which Jarvis experiment variants a requirement applies to and show that scope in the Requirements panel, so variant-specific instructions stay distinct in a shared session. Requirements without a variant scope still apply to all variants.

Improved

Pin screenshots are stored clean, with the pinned element's position as data

When the agent pins a note, the screenshot kept on the annotation used to have the red frame painted into the image itself. Anything that showed the pin later — the annotations sidebar, Jarvis, Ideas Lab — could only show that exact red rectangle, and could never hide it, pad it, pulse it or restyle it.

The annotation now stores the screenshot of the page exactly as it looked, plus where the pinned element sits in it. The highlight is drawn when the pin is shown, the same way QA-report screenshots already highlight the element a test step targeted, so it can look however the surface showing it needs. The agent itself still sees the framed version while it works, so its check that the right element was pinned is unchanged.

Pins made before this change keep their framed screenshots and show as before.

Fixed

The agent no longer pins an element that a popup is covering

When the agent pinned an element while a popup, cookie banner or modal backdrop was painted over it, the pin’s framed screenshot showed the popup instead of the element.

create_annotation now checks what is actually painted at the element’s centre before it pins. If that is another layer, the pin is refused and the agent is told what covers the element — the layer’s tag, id or class, role and text (or its iframe’s title, for popups that render in an iframe) — and to close it the way a user would (its close button or Escape) and pin again. Nothing on the page is changed by the tool: the popup stays until the agent dismisses it, and a site’s own sticky header that merely clips the element’s edge does not block a pin.

Fixed

Sub-agent parents keep hearing their children after answering a relayed question

When a sub-agent asked a question, the parent relayed it to you and passed your answer on, the parent then went silent: the children finished and their results showed in the Sub-agents panel, but the parent never read them or wrote its summary until you typed something. The parent now picks each child result up as soon as it lands, exactly as it does when no question was asked.

New

Opt a session into sub-agents from the Session API

Sessions created through POST /api/session can now delegate work to sub-agents — but only when you ask: send "subAgents": true in the request body and the agent gets spawn_agents and the other delegation tools; leave it out (or send false) and the session behaves exactly as before. A non-boolean value is rejected with 400 subAgents: must be a boolean.

Sessions started from the Mark-17 app are governed by the sub-agents feature flag instead, evaluated for the person running the session.

New

Stop one agent, or the agent and its sub-agents

While an agent that has delegated work to sub-agents is running, the Stop button now stops only that agent — its sub-agents keep working and report back when they finish. To stop the whole tree, open the menu next to Stop and choose Stop this agent and its sub-agents: each stopped sub-agent leaves one “stopped” card in the chat.

A sub-agent’s card no longer waits for your next message when it arrives while the agent is paused on a question of its own — it lands as soon as you press Stop, or as soon as the current turn settles.

Improved

The agent's framed pin screenshot shows the whole screen around the pin

When the agent pins a note, it gets back a screenshot of the page with the pinned element framed in red. That shot used to be a tight crop around the frame — roughly a third of the screen — so the agent could see the element but not where on the page it sat, which made it harder to judge whether the right thing was pinned.

The screenshot is now the full screen the pin was scrolled into view on: the whole width of the browser window and its full height, with the frame near the middle wherever the page allows. Pins near the top or bottom of a page still show the whole frame, and nothing changes for a person who has Annotate open.

The agent can now also pin an element taller than the screen — a whole section or page column. Before, such pins were refused and the agent had to pick something smaller inside. The screenshot for a tall pin is a taller screen: the whole element with a little page above and below it, and the page’s sticky header and bottom bars where you would see them on a screen that tall, not scattered through the middle of the picture.

Fixed

Agent pin screenshots no longer show another pin's red frame

When the agent pinned several elements at once, the framed screenshots it got back could carry two red frames — one capture started while another’s frame was still on the page. Framed captures on a page now run one at a time; unrelated tool calls stay parallel.

Fixed

The agent's framed pin screenshot shows only the page and the red frame

When the agent pinned a note, the screenshot it got back — the page with its pin framed in red — also showed the annotation overlay’s own markers and dashed outlines: the pin it had just created and every earlier pin on the page. Around the red frame that read as a second highlight on the same spot, or as a frame on the wrong element when an older pin’s outline overlapped.

The overlay is now hidden for the moment the screenshot is taken and comes straight back afterwards, so the agent sees the page exactly as a visitor does with only the red frame added. Pins stay where they are; a person who has Annotate open sees no change.

New

Point an API session at the Jarvis that launched it

POST /api/session now accepts mcpServers: { "jarvis": { "url": "https://<your-jarvis-api>/api/mcp" } }. Instead of adding another server, it points the session’s built-in Jarvis tools (mcp_jarvis__*) at that Jarvis — so a session started from a Jarvis preview uses the preview’s tools rather than production’s. The session keeps authenticating with its own Jarvis token; sending headers for jarvis is rejected. Sessions that don’t send it work the same as before.

New

Jarvis can add a variant to a session that is already building the experiment

An experiment usually gets one Mark-17 session: it builds every variant, so the variants share code, fixes and context. Until now a variant created after the session started could only get a session of its own. Jarvis’s Build dialog can now pick the experiment’s existing session for a new variant; the session’s variant list grows (the Publish panel shows the new variant too) and Jarvis is told the session now covers it, exactly as when you assign a variant in the Publish panel.

Messages Jarvis sends to a session about a new or updated variant can now be queued (delivery: "queue"), so they wait for the agent to finish its current turn instead of interrupting it.

For integrations: variants are added with POST /api/sessions/:sid/jarvis/variants; a session’s whole Jarvis association (experiment and variants together) can be replaced in one call with PUT /api/sessions/:sid/jarvis.

New

Bring another session's published variant into your workspace as reference source

The agent can now pull the readable source of a variant that was published from another Mark-17 session into the current session, with the new import_published_variant tool. Give it the other session’s id, the coframe_variant_id of the preview you want, or both: with both it fetches exactly that publish, with only the session it takes that session’s latest publish, and with only the variant id it finds the session through your Jarvis experiment.

The files land under published-variants/<session>/<variant>/ — next to, never inside, the variant-src/ the session builds from — together with the publish metadata, so several published variants can sit side by side in one session and be compared, diffed or merged by hand. Imports work only inside the Jarvis organisation the session belongs to; a publish from another organisation reads as “no access”, and a session with no publishes, an unknown variant id, or a publish that kept no source are each reported distinctly.

New

Embed the editor with only the panels you want

Sites that embed a Mark-17 session can now shape what it shows:

  • ?embed=focus&hide=chat,requirements opens the full editor without the listed panels. The remaining panes fill the space, and a hidden panel stays hidden even when it would normally appear later (for example Requirements once the agent captures some).
  • ?embed=focus&show=preview,files is the inverse: only the listed panels.
  • ?embed=card&panel=<panel> embeds a single panel with no editor chrome, and now accepts every panel — Chat, Browser (preview), Requirements, Files, Tasks, Tests and the rest.

Without these parameters the editor opens exactly as before.

Fixed

Agent pins land on the visible element and come back with a highlighted screenshot

When the agent pinned a note on a page that renders a hidden twin of an element ahead of the visible one (a mobile copy of the product name, price or delivery date), the pin landed on the hidden copy: a 0×0 box at the top-left corner of the page, and a blank thumbnail wherever the pin was shown later. The agent was told only that the selector matched, so it never noticed.

Pins now go on the first element that is actually rendered, and every pin the agent creates comes back to it with the element it landed on (tag, text, size, how many elements the selector matched) and a screenshot of the page with the pin framed in red. The agent is asked to look at it and pin again when the frame is not the element its note is about. The screenshot is also attached to the annotation, so it opens with the pin in the Annotations panel.

A pin is one rendered element that fits on one screen: a selector resolving to several rendered elements is refused with their texts, and an element taller than the viewport is refused with its size, so the agent narrows the pin instead of annotating a whole section.

The framed screenshot stays with the pin: when the agent later opens an annotation (for example after a long session has compacted its earlier work), it sees the same framed image again instead of only the selector.

Improved

Full-page previews up to 12,000px tall can be saved

Asking the agent for a full-page desktop or mobile preview no longer stops at 8,000px. Variant previews can now be up to 12,000px tall, and a page taller than that can be saved as a full-page capture shrunk to fit, as long as it stays readable. Before, long pages left the agent asking how to crop them.

Fixed

Custom proxy routes now work on bot-protected sites

A Browser Policy custom proxy route is checked before a session uses it. That check used to ask the proxy to fetch your page with a plain, non-browser request — and sites behind a bot wall answer such a request with “access denied”, so the healthy proxy was reported as unavailable and the session fell back to a direct connection on exactly the sites the route was created for.

The health check now asks only whether the proxy itself is reachable. Routed sessions on bot-protected sites open on the custom proxy as configured.

Fixed

Fewer bot walls: the browser keeps the clean session it already earned

Sites behind a bot wall (HUMAN / PerimeterX and the like) score the browser session, not just its exit IP — and the editor used to hand them a brand-new session at every turn: one per end-to-end test attempt, a fresh browser on every still-blocked re-check, another after an idle expiry. Each of those restarted the scoring from zero.

Now the first clean read of your target captures its first-party state, and every browser the session creates for that site afterwards — e2e test browsers and replacements alike — starts from it, so the session continues the one the wall already let through. Fresh sessions on a walled site are paced instead of opened in a burst, and a still-blocked browser on the same proxy is kept and re-checked rather than replaced.

Site Config recommendations are also applied in full when a browser is created: a verified recommendation sets the proxy, stealth, GPU and viewport on both the main browser and the e2e test browsers (previously only the proxy), and an inferred recommendation sets the proxy. The create-time lookup waits 3 s instead of 2 s for a cold recommendation service.

Playwright e2e scenarios now run with the test browser’s real user agent instead of a stale Windows Chrome/119 one substituted by the Workers Playwright client — the mismatch with the browser’s client hints was what bot walls such as HUMAN/PerimeterX rejected on every e2e scenario.

Fixed

Long structured sessions deliver one result, at the end

A session that asks for a structured result (an outputSchema on the API) and runs long enough to be checkpointed and continued automatically used to publish a result at every checkpoint — an incomplete one mid-task, then the real one — and the continuation would read the first as “truncated” and spend steps re-checking it. The result is now collected once, when the work is actually finished; a checkpoint the platform will continue publishes nothing.

Fixed

The agent can pin a page during an unattended run

create_annotation used to fail with “the annotation overlay is not installed” whenever nobody had the session open — the overlay was only injected while a viewer tab was active. A running turn now keeps the overlay installed on its own, so API-launched and headless sessions (Jarvis Ideas Lab, Jira-driven runs) can leave pins on the live page exactly like an attended session, and the overlay is removed again when the turn settles and no viewer is left. The overlay is only held for turns that actually run — a turn parked for Jarvis re-authentication or refused before its first model call never keeps it — and a turn that starts while the browser is still being created gets the overlay the moment the browser is ready.

Fixed

Resolved annotations leave the page

When the agent (or you) resolves or dismisses an annotation, its pin and outline now disappear from the live page the moment the status changes — the way they did before the Annotations inbox — instead of staying behind as a faded red box.

What you’ll see

  • Resolve a pin, or let the agent resolve it after a build, and the page no longer highlights that element. Only pins in the Open tab are drawn on the page.
  • The record stays in the Done tab with its thread and its number. Show on page on a Done row still brings that one pin back (dimmed, with its ✓ or ×) so you can see where it was — replies you add keep showing in its thread — and it clears again on the next page load.
  • Reopen puts the pin back on the page immediately.
  • Resolve inside a pin’s own thread on the page now moves it to Done too — the inbox and the page always agree.
Fixed

The structured result folds, opens one section at a time, and always closes the reply

The structured result card at the end of a reply now has a fold control in its header, so the whole result can be collapsed to a single line and opened again. Every top-level section of the result starts closed, so a large result reads as a table of contents — open the section you need. The card also always renders after the reply’s final text: a reply recovered after an interruption used to show the result in the middle of the text it belongs to, followed by a replay of the reasoning that produced it.

Fixed

Structured sessions refuse an unsupported schema in seconds, not after the whole run

A structured session (outputSchema) now checks the schema with the model provider before the agent starts working. Each provider has a ceiling the schema validator cannot see — Anthropic refuses schemas whose compiled grammar is too large, Gemini refuses very wide ones — and until now that refusal only arrived at the final structured-output call, after ten minutes of paid browsing and analysis. The check is one tiny request; when the provider refuses, the run ends immediately with the provider’s own message and agent/status.deliverable reads failed, so you can trim the schema or switch model right away.

Fixed

Playwright BDD scenarios run on real iPhone and Android devices

A Playwright BDD scenario that starts with Given I am using Android Chrome on a Phone (or iOS Safari on an iPhone, or the matching @app: / @device: tags) now runs on that real device. Before, such a scenario failed on Mark-17 with an undefined step instead of reaching the device. Scenarios that name no browser still run on desktop Chrome, as before.

Improved

Structured sessions return the model's native structured output — no submit tool, no accept/reject step

A headless session created with a schema (outputSchema, formerly doneSchema) now ends every turn with a JSON value produced by the provider’s own structured-output mode: the agent browses and analyzes with its normal tools, and when it ends its turn the editor makes one more tool-free model call with your schema as the response format. The submit_done tool, the pendingSubmission pause and the submission.* webhooks are gone — read the result from agent/status.deliverable (pending → ready with the value, or failed with the reason when the model refused, was cut off, or missed the schema twice — a first miss on a constraint such as maxLength gets one correction call) and iterate by sending a follow-up message. The result survives restarts and is shown in the editor transcript as a structured card with expandable fields, tables for lists of records, safe links, and a raw-JSON view you can copy. Intakes that still send doneSchema are rejected with a message naming outputSchema.

New

Test on a real iPhone or Android phone from the browser picker

The browser chip above the preview now picks the browser, the device and — for desktop Chrome — the window size, all in one menu. Pick iOS Safari · iPhone or Android Chrome · Phone (or a tablet) to work on a real device: you can tap and type on it in the preview, and the agent browses, clicks and screenshots it the same way it does desktop Chrome. The page you were on carries over; sign-ins and cookies don’t. If no device is free, you stay on your current browser and get a clear message.

The agent can switch devices too (set_browser_settings), and Playwright BDD scenarios can start with Given I am using iOS Safari on an iPhone (or Android Chrome on a Phone) to run on a real device.

Improved

A shorter model picker: Smart, Balanced, Fast — and Lightspeed in Flash

The model picker now offers three Popular choices — Smart (Claude Opus 5.5, the default), Balanced (Claude Sonnet 5.5) and Fast (Gemini 3.8 Flash) — plus Claude Opus 5.5, Claude Sonnet 5.5 and GPT-6.1 Sol by name. The long tail of models nobody was picking is gone from the list.

Lightspeed (Cerebras Qwen 3.8 27B) is now a Flash-mode model only: it is Flash’s default coder, and Flash’s critic defaults to Smart. In Build and Prototype it no longer appears in the picker.

Sessions that were on a model that is no longer offered — or on Lightspeed in Build or Prototype — switch to Smart automatically: the composer shows Smart and the next message runs on Claude Opus 5.5. Queued messages and API requests that name a removed model are refused with an explanation rather than run on a substitute. Nothing in the session’s history changes.

Fixed

A follow-up reply sent from Jarvis reaches the agent's thread

When an annotation was reopened in Jarvis and sent to the session again with a new reply — “now also do X” — the agent re-read the thread as it stood before and repeated its earlier answer, because the session kept only the annotation’s status from the re-send and discarded the replies it carried. The replies the session does not yet have are now added to the thread (its own replies, echoed back, are not doubled), so the agent reads the follow-up and answers it.

Fixed

Walkthrough stops and imported pins appear on the page without a reload

Pins that were not placed on the page itself — the stops of a recorded walkthrough, or annotations imported from Jarvis for the page you are on — showed up in the Annotations panel but not on the page until the next reload, and “Show on page” answered that the pin was not on the current page. The page now receives these pins the moment they are recorded, so “Show on page” opens them right away.

Fixed

Pins sent together are numbered in the order you placed them

Placing several pins and sending them in one message gave them numbers in an arbitrary order (the third pin could become “1”) because every pin in the message was stamped with the moment the message was sent. Each pin now keeps the moment it was placed, so pin numbers on the page and in the Annotations panel follow the order you worked in.

Fixed

A pin you place takes the same number as its Annotations row right away

When the session already held an annotation on another page (for example one sent from Coframe), a pin you placed and sent on the current page was drawn with the wrong number — the page counted only its own pins (“1”) while the Annotations panel numbered it across the whole session (“2”) — until the page was reloaded. Reopening a resolved pin brought the wrong number back. The page now receives the panel’s number the moment the annotation is sent, so “pin 2” names the same annotation on both.

Fixed

Annotation replies and resolutions reach Coframe again

When Coframe opened a session in the editor and sent it annotations, the reply the agent wrote and the Resolved/Dismissed state you set in the editor never showed up back in Coframe — the comment stayed on “Sent”. Opening the session in a browser you were logged into replaced the session’s Coframe credential with your personal one, which is not allowed to post those updates.

A session now keeps the credential Coframe gave it; your own login is only used by sessions that have none. Updates that were held back deliver as soon as the session is next opened or messaged.

Improved

The browser opens a few seconds sooner when Coframe re-checks a site's settings

When you open a session on a site Coframe already knows, it briefly re-checks which browser settings still work before opening the browser. That check usually finishes in a few seconds, but the browser used to wait a full ten seconds before noticing. It now looks again after 2 s, 5 s and 10 s, so the Checking which browser settings work… card is gone about five seconds earlier on most sessions. Sites Coframe has never seen still take as long as the full analysis needs, and Open directly anyway / Choose a location… work exactly as before.

Fixed

Annotation replies and status changes from Mark-17 were not reaching Jarvis

A comment sent to Mark-17 from a Jarvis experiment stayed on “Sent to Mark-17 · awaiting agent” even after the agent had replied and the annotation was resolved in the editor. Mark-17 now reports every reply and status change back to Jarvis, so the comment’s badge moves to “Acknowledged” and “Resolved” as it happens; updates that were still queued for retry are delivered on their next attempt. A comment whose updates had already given up before this fix (after about a day of retries) does not catch up on its own — send it to Mark-17 again from Jarvis to get a fresh reply.

Fixed

The Design System brief reaches a build's first turn even when the session is slow to start

Builds launched from Jarvis sometimes started their first turn more than 15 seconds after the session was created while the sandbox was booting. The Design System brief was already on its way, but the turn only waited for it when the session was young, so a late-starting first turn ran without the brief — and a one-turn build never received it at all.

The wait is now counted from the moment the first turn actually starts, so a slow start no longer costs the brief. If the brief still has not arrived within that window, the agent is told plainly that the Design System is still loading and to derive brand rules from the live page’s CSS meanwhile, and the session records that the brief was deferred rather than leaving no trace.

Improved

Annotations stay current for the agent instead of being pasted into every message

Sending annotations used to paste a large copy of every pin into the message, and the agent kept re-reading those copies on every turn — long walkthroughs were trimmed to fit. Annotations are now kept once per session and the agent sees a short, always-current line for each: who made it, where it is, what it says and its present status, including replies and resolutions made after the message was sent.

Walkthroughs are no longer trimmed: every clicked or selected element becomes its own pin under the walkthrough, and the full transcript, hovers and screenshots stay available to the agent on request. Feedback sent from Coframe arrives the same way, and the agent’s replies and resolutions flow back to the Coframe thread they came from. Reopen a resolved annotation in Coframe and send it again and the agent sees it as open again, marked as reopened by you so it does not mistake it for work it already finished — its next resolution flows back too.

New

The Annotations panel is now an inbox: what's open, which pin it is, one next step

The left sidebar’s Annotations tab lists every pin the agent has received — the ones you sent in chat, the ones that arrived from Coframe, and the notes the agent pinned itself. Pins you have saved but not sent yet stay in the composer and are not listed; the panel is the record of what the agent actually knows about.

It reads like an inbox. Two tabs, Open and Done, each with its count. Every row starts with the same number the pin shows on the page, then the comment, who made it and what happened last — “Agent working”, “Resolved by Agent”, “Reopened by you” — and the agent’s latest reply. One button per row closes or reopens it; the change applies at once and can be undone from the strip under the tabs. Open a row to see the element, show the pin on the page, read the thread, reply, dismiss, or jump to the message that sent it. A walkthrough shows how many of its stops are still open and expands to them. When pins span several pages the list is grouped by page.

“Show on page” and the live status mirror now always address the tab you can see, even while the browser keeps a hidden standby tab behind it. Removing a pin you have not sent yet now also takes its marker off the page — on every tab the browser holds, and it stays gone after a reload. Both keep working after the editor reconnects — previously a reconnect could leave the page frozen on stale pins until you switched tabs and back.

New

Ask the agent to review the page — it leaves its notes as pins on the live view

Ask the agent to review, critique or QA the page and it now answers on the page itself: each observation becomes an annotation pinned to the element it is about, labelled as the agent’s, with the same thread and resolve controls as your own pins. The notes are for you — they never get folded into your next message as feedback to the agent — and they stay in place when the page navigates or reloads.

When the agent has addressed one of your annotations (or one of its own), it marks the pin resolved and leaves a one-line reply in its thread saying what changed — on the page, in the Annotations panel, and back in Coframe when the feedback came from there.

New

Give an API session its own instructions, MCP servers and capabilities

POST /api/session now takes three optional fields so other apps can run the Mark-17 agent with their own setup:

  • systemPrompt — your instructions, added after the Mark-17 prompt (it never replaces it).
  • mcpServers — remote MCP servers ({ id: { url, type?, headers? } }) whose tools the agent can call as mcp_<id>__<tool>. Headers stay on the server and are never returned or shown in the transcript. tools.exclude now also hides MCP tools, by exact name or a mcp_<id>__* prefix.
  • capabilities — { browser: false } or { sandbox: false } stops the session from starting the Kernel browser or the sandbox and removes the tools that need them. sandbox: false also turns the browser off.

All three are fixed when the session is created. Sessions that don’t send them work the same as before.

Fixed

The "which location?" question closes itself once Coframe finds settings that work

When Coframe finds browser settings that unblock a site, it closes its own “which location?” question and carries on — you no longer have to answer it. The card reads “Coframe found settings that work — no answer needed.” and the agent continues from the settings that landed. If you had already answered, your answer stands.

Improved

The browser waits for working settings before opening a site that may block it

When you open a site Coframe hasn’t checked recently, the shared browser now waits for Coframe to work out which browser settings get through — instead of opening right away and running into a block on the first page load. The browser card shows what it is waiting for and how long it can wait (up to six minutes), and you stay in control: Open directly anyway opens it immediately without a location, and Choose a location… opens it from the location you pick. Nothing changes for sites Coframe has already checked.

New

Design System brief is offered as reference on sub-brands and staging hosts

When a session edits a host the organization has no Design System profile for — a sub-brand, a regional site, a staging domain — but the organization has exactly one profile for another host, Mark-17 now receives that profile as a reference instead of being told only that it exists.

  • The brief is labelled with both hosts: measured on the profile’s domain, this page is the session’s host. The agent is told to read the page’s own computed styles first, use the profile to recognise the brand and fill gaps, and let the page win where the two differ.
  • A reference profile vouches for colours you ask for but never flags the page’s own colours as off-brand; that check stays reserved for a profile measured on the page itself.
  • Profiles measured on the session’s own site keep working as before; the brief now also names the session’s host when it differs from the profile’s domain (for example app. versus the apex).
  • Organizations with several profiles for other hosts are unchanged: no guess is made, and the brief names the candidates.
New

Sessions opened from an experiment start on its target page

A session created from a Jarvis experiment now opens on the experiment’s target page as soon as the experiment resolves, instead of waiting for the first set_preview_target. The Design System brief and the site configuration are therefore ready before the first message, not after the agent’s first navigation.

A target you or the agent set is never overridden: the experiment’s page is used only while the session has no target of its own.

New

Build up an AI harness, one layer at a time

Before revealing AlphaCRO’s results, a centered question asks how a harness built for Coframe handles coding tasks it wasn’t optimized for, using the same agent and harness without changes. The phrase “it wasn’t optimized for?” stands on its own line in warm coral, making that premise clear from a distance.

The ranking first introduces “AlphaCRO” at 80.0%, without revealing its mode. The question and mode cues type in, and the existing result gains a typed “Prototype” suffix. Only Prototype’s faster-and-cheaper label appears at that stage; Build’s label arrives with its 81.1% result. The final cue reads “One harness.” and “Two modes.” on separate lines. The following charts compare their accuracy, cost and time.

The finale first shows AlphaCRO powering Mark-17 today. Next types “The same harness. Soon, for every team.” A second Next reveals the company-wide uses, including CroBot, under “Coming soon · across Coframe.”

The infrastructure view describes the Agents SDK’s role as “Shared sessions. Live responses.”

Taller, wider cost and time plots make the results easier to compare at a distance, with one Accuracy axis title, more space between labels and the same scales throughout the reveal.

After Build appears on the cost and time plots, Next goes straight to the finale. The extra bottom summary and its click are removed.

The completed robot lifts both fists beside its head in a two-arm flex, with neither hand hidden behind its face.

The Mark-17 announcement’s future messages stay hidden from screen readers until the presenter reveals them; printed slides include the complete announcement.

After Mark-17 lands, the announcement reads “Please welcome…” before the next slide introduces its name.

State is illustrated with a concrete work record—file edited, tests failed, fixing the error—instead of an ambiguous backpack. The next step shows the same record as a saved checkpoint to explain durability.

The presentation opens with “Agent Eng Presents”, then the two video slides announce Mark-1’s retirement and Mark-17’s arrival. “Trust me.” crossed out by one light rising stroke above “Show me.” follows the announcement. Both opening cards omit slide numbers. Next introduces “Harness.”, then two clicks ask what it is and what it takes to build. “Let’s build one.” begins the model-building story. The deck has 18 slides. Prototype’s results show 80.0% accuracy and 16.0 minutes average time per task.

alphacro-harness builds a harness around a small robot, one layer at a time, then zooms out to its Cloudflare and Kernel infrastructure. Eighteen visual Show and Tell slides include the retirement announcement, engineering work and benchmarking. An empty stage introduces Mark-17, then the heading erases and types an invitation to welcome AlphaCRO, our internal codename, with “The harness behind it” typed beneath. Prototype appears before Build against familiar harnesses. Large rankings and side-by-side accuracy/cost/time charts keep the same scales as AlphaCRO enters, with fewer numbers and stronger visual emphasis on its results. The ranking scale and caption appear with the results. The finale previews company-wide availability. Next controls each reveal; the retirement scene keeps its original idle loop, while arrival and hero clips play once. Includes speaker notes and a printable deck. Returning from print preserves the active slide without replaying its entrance.

New

Slides: Mark-1 is retired, new builds happen in Mark-17

A two-slide announcement deck at /slides/mark1-retired/ for team sessions: Mark-1 rocking on its porch, Mark-17 touching down, and the one thing to remember — your existing Mark-1 builds are still there; to keep working on one, open the variant and use Build ▾ → Migrate from Mark-1.

Improved

Flash tells you when a single message is too large for its model instead of silently trimming it

Flash works from a compact view of your conversation, so a very long message — a pasted brief, a transcript, a block of numbers — could previously be cut down before the agent read it, with nothing to tell you that happened. Now, when your latest message on its own would not fit the selected model’s context window alongside Flash’s working state, the turn is refused before anything runs: no page capture, no plan, no code, no model call. The message stays in the transcript exactly as you sent it (it is never turned into an attachment on your behalf), the banner says why, and a one-click “Switch to Prototype” moves your next message to a mode whose engine condenses history instead of refusing. Ordinary messages are unaffected. The session’s debug inspector also gains a per-compaction card with the prompt’s seven budget terms (fixed, standing, head, record, bridge, tail, headroom), the record horizon as a stable message position, and bounded counts — never the text of what you or the agent said.

New

Large pastes and files you send are kept exactly, and the agent can copy any of them into the workspace

Pasting a very large text into the chat (64 KiB or more — roughly a thousand lines) now attaches it as a file instead of inlining it: the full text is stored byte-for-byte as evidence, the model receives a short descriptor with a reference it can read in pages with read_tool_result, and the paste stays visible and undoable in the composer until you send. The same applies to files other than images (CSV, JSON, logs, PDFs, …) dropped into the composer or sent through the REST API’s new files field: each keeps its name, type and exact bytes, up to 48 MiB. Retrying a send after a lost connection re-uses the same attachment instead of creating a duplicate, and the API accepts a standing flag for an attachment-only message that carries no text. When the agent needs the file on disk — to run a script over your CSV, open your PDF, or diff your log — it calls copy_evidence, which writes the exact bytes to a path you can see inside the workspace and reports the size and checksum it verified; it refuses paths outside the workspace and attachments from other sessions.

Improved

The agent can re-read any earlier message of the conversation exactly, even after its context was compacted

Long sessions compact older turns out of the model’s working context. Until now, a user message or agent reply that fell outside that window was gone from the agent’s point of view — it could only rely on the summary. The agent now has two tools for exact recall: list_transcript pages through the conversation newest-first (who said what, when, how long each message is, and an opening preview), and read_message returns the exact text of any message — the whole thing or a precise range of lines, characters, or bytes — along with a checksum of the full body. Messages are addressed by their position in the conversation (msg:12, or msg:12/p2 for one part of a multi-part message), so the agent can quote your instructions verbatim or check its own earlier reply no matter how far back it was. When the agent remembers roughly what was said but not where, search_transcript finds it: a word search over the current conversation (edited messages answer with their latest wording, deleted ones not at all) that returns each hit’s message reference, line number and a short highlighted excerpt, so the agent can jump straight to read_message for the exact text. Each session can only read its own history; a forked session carries the history it was forked with.

Improved

The API tells you exactly which message it saved, and where

When you send a message to a session through the API (POST /api/sessions/:id/agent/messages or POST /api/variants) and then poll the request’s status URL, the response now includes a receipt for the message it saved: the message’s position in the conversation (msg:12 — the same address the agent uses with its read_message tool), a checksum and size of the stored message, and for each part — your text, each attached file — its own checksum, size and line count. You can verify that what you sent is what landed, byte for byte, and quote the exact address back to the agent later (“re-read msg:12”). The receipt appears only once the message is durably stored; a request whose save failed has no receipt rather than a misleading one.

Improved

Very long conversations keep going — older messages move behind the summary instead of stopping the session

Until now a session whose messages alone outgrew the model’s context window stopped with “the conversation is too long to continue”, even though the agent compacts older turns — your own messages were always replayed in full, so enough of them ended the session for good. The agent now keeps a bounded window of your most recent messages verbatim and lets the older ones fall behind its running summary, exactly like earlier tool output. Nothing is lost: every message stays stored line for line, and the agent re-reads any of them exactly with read_message (or finds it with search_transcript) whenever a task depends on the precise wording. The context inspector shows where that window starts (“Record horizon”) and how the prompt budget is spent.

Improved

Variant monitor runs finish right after their last test

Monitor runs no longer sit on “running” for minutes after every test has finished. Screenshots are now saved straight to the report’s image storage as each test takes them, so nothing is copied at the end and the report is ready a few seconds after the last test. The same applies to the Tests panel’s Playwright results.

While the report is being saved, the run says so: its status carries phase: "saving_report" and the report page reads “Saving report — every test has finished”.

Improved

The agent can lock the browser's operating-system name in place

Some sites check which operating system the visitor’s browser reports and switch off their own scripts for some of them. Until now, only you could tick “Also lock the operating-system name in place” in the browser settings. When the agent switched the operating system, the site could see the browser’s real one again after the agent’s next step. Now the agent can turn on the same lock when it switches the operating system for a site like this, so the page keeps loading the way real shoppers see it.

New

Re-run a session's tests against a live variant on demand

Mark-17 sessions can now be monitored: an external scheduler (for example a daily Jarvis job) can ask a session to re-run its Playwright-BDD tests against the variant Coframe is serving right now, and read the results back.

  • Real delivery. The variant is applied by the page’s own Coframe SDK through ?coframe_variant_id=rollouts,<id> — the same code visitors get, including hotfixes and rollbacks. If the SDK is missing the run fails with sdk_not_detected; there is no injection fallback. rolloutAware: false and control: "disabled" switch to a pure-preview / cf_disable baseline.
  • Right tests per variant. Scenarios targeting a label or parameter binding only run on the variant built with it; others are skipped with a reason (label_mismatch, binding_mismatch, variant_config_unresolved, node_identity_across_navigation). A run where nothing applied is reported as an error, never green.
  • Errors vs failures. failed means the tests ran and an assertion did not hold on the page. Problems with the check itself — the test browser disconnecting, the browser service being unreachable, a bot wall — end as error instead, so neither reads as passed and each points at the right thing to investigate.
  • Separate from editing. Monitor runs have their own history and never wake the session, touch its Tests panel, cancel a build run, or trigger a fix.

HTTP: POST /api/sessions/:sid/monitor/runs to start, GET .../monitor for the latest result per variant, GET .../monitor/runs[/:runId[?sinceSeq=N]] for history and progress, .../report for the full report and .../cancel. Live progress streams over the WebSocket at /agents/variant-monitor/:sid using the same seq cursor as polling.

Fixed

Parameterized landing pages render in the Landing Page preview

Landing pages that read their values from @coframe/variant-params — including nested groups such as @coframe/variant-params/visitor — used to fail in the Landing Page preview with “Bare import … is not in the import manifest”. The preview now evaluates the workspace’s parameters.ts and renders the page with its defaults, and ?cf_params.<path>=<value> in the preview URL applies a partial binding on top (for example ?cf_params.visitor.role=it_admin). Pages that import parameters.ts itself (and therefore zod) render too.

Improved

Brand check recognises the focus ring colour of each control kind

Jarvis’s Design System now keeps a focus ring per control kind when a site styles them differently — the CTA, inputs, navigation and body links. The advisory brand check vouches for each of those measured ring colours, so an input ring that differs from the button ring is no longer flagged as “off-palette” when the agent reproduces it.

Fixed

E2E tests use the target's configured connection even before the session's browser has opened

When a session’s browser had never been opened yet, running the e2e tests could reach the target from the default connection, even though opening the browser would have switched the session onto the connection configured for that site — your organisation’s custom route or the country Site Config recommends. Sites that only admit that connection then refused the test run.

E2E tests now set up the browser exactly the way the session’s own browser is set up on first open: the target’s configuration is looked up and applied first, then the tests run through the resulting connection. A session that has already opened its browser is unaffected.

Fixed

E2E tests no longer refuse to run after the session's browser went idle

After a session’s browser had been idle long enough to be closed, re-running the e2e tests kept failing before any test ran, with “browser egress not converged — the last read-back is for a browser since replaced”, even though nothing about the session had changed. Waiting did not help: a test run never brings the session’s browser back, so there was nothing to wait for.

E2E tests now run in that state too, on the same connection the session’s browser is configured for — your organisation’s custom connection or chosen country — exactly as the browser itself would be created. If that connection can’t be set up right now, the run still says so instead of running from somewhere else.

New

Headless analysis sessions with a structured deliverable

POST /api/session accepts two new optional fields:

  • doneSchema — a JSON Schema for the session’s deliverable. The agent browses and analyzes, then submits its result through a new submit_done tool that must match the schema. The session pauses until you accept or reject the submission (agent/status shows it as pendingSubmission; answer on agent/elicit). Rejections carry reasons the agent sees and fixes before resubmitting. submission.pending / submission.resolved webhooks push each step to your callback.
  • tools — include / exclude lists that narrow the session’s tools. Sessions with a doneSchema default to a read-only analysis toolset, so they never apply or publish variants unless you opt a tool back in.
Fixed

E2E tests were blocked on sites that need your organisation's connection

When a session browsed through your organisation’s own connection (a custom proxy set in Jarvis browser settings) or a chosen country, the automated e2e tests still ran from a separate default connection. Sites that only allow that connection, such as an IP-allow-listed QA host, answered “Access Denied” in the tests while the same page loaded fine in the session’s browser.

E2E tests now browse through the same connection as the session’s browser. If that connection can’t be used for a test, or the browser hasn’t finished switching to it yet, the test run reports that instead of quietly running from somewhere else.

Improved

One edit tool per session, Morph fast apply by default

The agent now has exactly one file-editing tool, edit_file, in every session. Which editor answers to that name is a deployment setting rather than two tools competing in the same chat: by default it is the Morph fast-apply editor — the agent shows only the lines that change between // ... existing code ... markers and Morph merges them into the file — and a deployment without a Morph key, or one that sets EDIT_FILE_TOOL=native, gets the built-in exact-replacement editor instead (replace one unambiguous snippet, report the changed lines, refuse an ambiguous match).

In the chat, every edit now renders as an edit_file card with the file name, the +added −removed line stat and the edit itself — the Morph instructions and snippet, or the built-in editor’s diff and, when it declines an edit, the reason — instead of the separate morph_edit card or a raw JSON block for built-in edits. Older sessions that recorded morph_edit still render as before. Two card fixes ride along: a Morph edit that replaces lines in place now shows its real +n −n stat instead of none, and expanding an edit or read card no longer swaps the file’s content in the Files editor for the card’s excerpt until reload.

Fixed

The agent no longer offers to change control or other experiment arms

A Mark-17 session builds one variant. Control is the live site as it is today, and each other arm of the experiment is built in its own session. The agent used to sometimes ask whether a change should also go to “all arms, including control”, and could even make that the default answer. Now it builds only the variant you are working on. If a change might muddy the test, it tells you in one line and then builds what you asked for.

September 2026

Fixed

A replay's Debug tab no longer lists the editor's own housekeeping errors

The Debug tab of a replay session describes the recorded run and nothing else. Replays imported with telemetry could end with an exception entry that came from the editor itself — a failed session-directory refresh while the import was still being written — rather than from the run. Errors of the editor’s own plumbing are now kept out of a replay’s telemetry from the moment the replay exists, so its event tail ends where the recorded run ended.

Improved

Operators can remove a frozen replay session

Benchmark replays imported into the editor can now be removed for good with DELETE /api/sessions/<id> and the operator bearer. The route removes only a frozen replay — the session decides from its own recorded state, and anything live is refused untouched with 409 not_a_frozen_replay — and takes the session’s storage, its directory row and its published images, workspace files and archive exports with it. A removed id is tombstoned so nothing can bring it back; the old share link answers 404 from then on, and an open Sessions list drops the row the moment it goes — no refresh needed. A replay whose import is still in progress is refused the same way a live session is, so a removal can never race an import. The FHE trajectory importer’s --prune-superseded uses it to retire the replays a verified re-import made redundant, listing exactly what it would remove under --dry-run.

Improved

Watch files being written live in the chat

When the agent creates or edits a file, its row in the chat now shows a compact, fixed-height live view of the last few lines as they are written — with line numbers, a blinking cursor at the write head, and a running line and size count. You no longer need to expand the row to see that something is happening, and the view stays small instead of growing to the whole file. Once the file is written, the row returns to the usual collapsed summary with the full diff one click away.

Fixed

Tool cards show what the model read for very long shell output

When a shell command produced more output than fits in the conversation, its tool card only showed the raw stored record — a head and a tail of the output inside a JSON envelope — while the agent itself had read a readable exit-code line and fenced output. The two no longer matched, so it was hard to tell from the card what the agent actually saw.

The card now shows a “model view” for those results, with the same exit code and fenced head-and-tail output the agent read, and the “Show full output” control below it still fetches the complete output on demand. The same applies to a long apply-variant result: its model view is the summary the agent read, including the pointer to the full console logs.

Fixed

Variants live on the same page no longer lose each other's styling

When two or more published variants ran on the same page, the one that loaded last removed the others’ styles, so an earlier variant could show up unstyled (for example, a call-to-action rendering as plain text). Each variant now keeps its own styles no matter how many variants are live or the order they load in. Republishing a variant still replaces its previous styles rather than stacking them.

The editor preview now runs exactly the code that gets published, so what you see while editing matches what visitors get.

Variants that were published before this fix still carry the old behavior until they are republished.

New

Read and answer a session's questions over MCP

The editor-web MCP server (POST /api/mcp) has two new tools for agents that drive sessions from outside the editor:

  • get_session_status shows whether a session is waiting on you, with the open questions and any pending approvals.
  • answer_session_questions submits answers to those questions. The answers are checked against the questions the agent asked and are recorded as coming from the user who owns the Jarvis API key.

Connect with your Jarvis API key (Authorization: Bearer jrv_…), the same key you use for the Jarvis MCP, with the same scope rules: the key needs a Jarvis MCP scope to connect, and answer_session_questions appears only for keys with agent:write.

Answers and approvals sent from outside the editor — over MCP, the REST /agent/elicit and /agent/approval endpoints, or the Slack question form and Approve/Reject buttons — now land exactly the way answers given in the editor do: the question and its answer stay in the chat history as an answered question instead of vanishing when the agent resumes. Answering a question that was already answered, or one the session has moved past, is now refused (409 already_answered / 404 not_found) instead of being accepted and silently dropped.

Fixed

Supervisor: a session you watch again reopens as you left it

On /supervisor, unwatching a session and watching it again (or hiding a watched session and clicking Undo) used to bring its pane back in the default mode and on the Chat tab. The pane now comes back in the mode (live or card) and on the tab (Chat, Browser, Components) you last had it on, even after a reload. It still rejoins the end of the Watching grid.

Improved

Supervisor: hide a session from your list in one click, with Undo

Hover any row on /supervisor and click the ✕ at its far right to hide it — no need to open the row’s ⋯ menu. Hidden sessions drop out of your list in this browser only; nobody else’s view changes.

Right after hiding, a line under the toolbar offers Undo (a session you were watching goes back into Watching) and Show hidden (N). Later, the foot of the list says how many sessions you’ve hidden, with Show hidden next to it. Hidden rows then show dimmed under a line explaining them; click the ↶ on a row to put it back in your list, or its eye to put it straight back into Watching. Back to my list leaves that view, and Unhide all stays under the toolbar’s options.

Improved

Custom proxy routes treat www.example.com and example.com as the same site

A Browser Policy custom proxy route lists the hosts it serves. Until now a host had to be spelled exactly the way the page is addressed: a route for interactivebrokers.ie did not apply to a session opened on www.interactivebrokers.ie, so the browser silently fell back to a managed proxy and the site’s bot protection blocked the page.

A leading www. is now optional on both sides. A route for example.com covers www.example.com, a route for www.example.com covers example.com, and a wildcard such as *.example.com still covers www.example.com as before. Everything else is unchanged: * still stands for exactly one label, qa.example.com still means only qa.example.com.

Improved

Landing page preview opens on its own

Switching to the Landing Page tab now starts the preview straight away, so you see your page without clicking “Start preview” first. If the preview can’t start, the tab still shows the error and a “Retry preview” button.

Improved

The Browser panel stays awake for five minutes while you read

The Browser panel’s live view used to go to sleep after one minute without a click, keystroke, or scroll, so pausing to read a page meant clicking to wake it back up. It now stays live for five minutes — the same window the browser itself is kept warm for between agent turns — so a follow-up prompt a few minutes later picks up the same page instantly.

Improved

Landing page previews start without a sandbox container

When the agent builds a landing page, Start preview now renders it on a dedicated preview service instead of booting a development server inside the session’s sandbox. Astro pages and components, TypeScript, Tailwind classes and interactive Preact islands all render as before, and the annotation overlay works the same way, so you can still point at part of the page and ask for a change.

Edits the agent makes appear in the open preview straight away: style-only changes swap in without a reload, and other changes reload the page. If the page can’t be built — for example because it imports a file that doesn’t exist — the preview says which file and why instead of showing a blank frame.

Improved

The Debug tab of a replay shows the recorded run's model calls, tools, timings and cost

Opening a replay session with ?debug used to show an empty panel: the Debug tab only knew about turns the editor itself had run, and a replay never runs one. A replay imported with telemetry now fills the same panel a live session has — the timeline of model calls and tool calls, per-tool durations and failures, model and provider identity, latency, tokens, cache hits and spend, the tool leaderboard and the raw event tail — reconstructed from the run’s own transcript and request audit, on the run’s original clock.

The panel says what it is looking at. Its header reads Replay debug, the status card names the benchmark verdict instead of “running” or “idle”, and a Recorded trajectory block shows the cell, arm, model as served, wall time, exit code and the run’s request count and cost, followed by how the telemetry was obtained: how many model calls were matched to audited requests, how many requests were verifier calls, retries or failures, and how much of the tool time was measured by the tool itself versus placed inside the gap between two model steps. Placed intervals are drawn dashed on the timeline and say so on hover. A replay imported before this change explains that it carries no telemetry rather than looking like a session that never did anything.

Because a replay cannot change, its Debug tab is read once on open instead of polling.

Fixed

Jarvis recovery no longer stalls inside the embedded editor

When Jarvis auth or the socket connection fails in an embedded Mark 17 session, the editor shows a calm “Connecting to Jarvis…” dialog while it recovers on its own. If that doesn’t succeed within a bounded wait, the dialog asks you to sign in to Jarvis right there, with opening the session in a new tab as a fallback.

Improved

Apply results keep up to 4 MiB of the page's console output

When the agent applies a variant, the console output it gets back from the page was capped at 768 KiB, so on a chatty page the lines around a failure could be the ones that were dropped. The capture now keeps up to 4 MiB (up to 100 000 entries), still favouring the first lines and the most recent ones, and still reports exactly how much was dropped when a page logs more than that.

Fixed

Preview and translation tools no longer corrupt manifests with invalid UTF-8

Recording a preview cell (set_previews, capture_preview, refresh_previews) or setting a translation (set_base_translations, set_variant_translation_override, delete_variant_translation_override) rewrites the whole variants.yaml or translation JSON file. If that file contained bytes outside UTF-8, every such byte was silently replaced with the \uFFFD character on the way back to disk. These tools now refuse to touch such a file and tell the agent to fix the file’s encoding with run_shell first. Files that are valid UTF-8 — including ones that legitimately contain \uFFFD — are edited exactly as before.

Fixed

The agent no longer corrupts files whose bytes are not valid UTF-8

Editing a text file that contained bytes outside UTF-8 (a stray 0xFF, a Latin-1 fixture, a truncated multibyte sequence) used to silently rewrite those bytes as the \uFFFD replacement character everywhere in the file, not just at the edited line. The agent’s edit_file, write_file, and morph_edit tools now refuse to touch such a file and tell the model to use run_shell for a byte-level change (or convert the file to UTF-8 first). Valid UTF-8 files — including ones that legitimately contain \uFFFD, a BOM, CRLF line endings, or no trailing newline — edit exactly as before, byte for byte.

Fixed

Tool cards show and fetch very large tool outputs on demand

A tool result too large to keep inline in the conversation is now stored as a short head/tail excerpt with an archived · N bytes stat, instead of the whole body weighing down every load and reconnect of the session. The card keeps showing that excerpt, and a Show full output control fetches the complete recorded body from the session’s evidence archive when you need it — including bodies that are no longer held, which the card says plainly.

New

Benchmark trajectories open as read-only replay sessions

Agent runs recorded outside the editor — for example a benchmark cell run through the CLI — can now be imported as replay sessions. A replay opens in the same editor as a live session: the prompt, the agent’s reasoning, every tool call with its output, the files it wrote, and its plan and requirements are all there to read.

What sets a replay apart is that it cannot change. The composer, branching, and every other way of steering the agent are off, and the session never starts a sandbox, browser, or preview — the panels that would need one say so instead. A banner at the top names the benchmark cell, the run, the harness, the model, how the verifier scored it, how long it took, and where the recording came from, so what you see is exactly what was measured.

Replays stay out of the sessions list until you ask for them with “Show replays”, and are badged as such when shown.

Improved

The full browser console from an apply is kept and pageable

Every console line the page and the variant printed while a variant was applied is now kept as its own record in the session’s evidence archive — one line per entry, oldest first — instead of being carried whole inside the apply result. The agent sees how many entries and bytes were captured (and how many were dropped, if any) and reads any range of lines it needs; the evidence API pages the same record by line, so a range of lines is exactly a range of console entries.

Fixed

Supervisor search finds any session in the window, not just the loaded ones

Typing a session id, experiment slug or title, variant name or target page URL into the Supervisor’s search box now asks the session directory for the matches directly. Sessions older than the first page show up straight away — no more clicking Load more until the one you are looking for scrolls in.

Fixed

Choosing an organization in the Supervisor keeps following it — new experiments join on their own

The Experiments filter in the Supervisor now treats what you tick as a tree. Tick an organization and every experiment under it is in your working set — including ones created after you ticked, the moment their first session shows up. Tick an experiment and every variant of it is in, however the variants change later. Ticking a single experiment no longer quietly turns into “the whole organization”, and an organization you chose is shown by name (with its own remove chip) even while the current window lists only one — or none — of its experiments.

Fixed

An automatic retry no longer disappears if the platform restarts while it is being scheduled

When a reply failed on the provider’s side (rate limit, outage, dropped connection), the session schedules an automatic retry. If the platform happened to restart in the split second between the failure being noticed and the retry being written down, the retry was lost: the transcript showed the failure and nothing resumed.

The retry is now written down before the previous safeguard stands down, so a restart at that moment resumes the turn as scheduled.

Fixed

Applying a variant on a page that logs heavily no longer fails, and the agent still reads the whole console

When the page under test writes a lot to the browser console — hundreds of console.log calls with long lines, as instrumented sites and SDK debug modes do — applying a variant could fail after the change had already rendered, and the console output the agent needed to debug the page was lost with it.

The apply now keeps the full console capture in the session’s evidence store instead of carrying it through the apply itself. The variant applies as usual, the agent’s read_tool_result and list_evidence page through every captured line, and the same evidence is reachable from the session’s evidence API. Sessions you copy or export carry it along.

Improved

Thinking from a dropped connection folds away instead of reading as the answer

When the connection to the model provider drops mid-thought and the agent reconnects in the same step, the thinking it had streamed before the drop used to sit in the transcript like any other thought — auto-opened while the agent reconnected, and labelled Thought for N seconds afterwards, as if it were part of the answer.

That block now folds under a single line, Connection to Anthropic dropped — retrying (naming the provider the turn ran on), stays closed while the agent reconnects, and only opens if you click it. The thinking the agent does after reconnecting is the turn’s own and reads exactly as before.

Improved

The agent edits files in place with a built-in edit tool

The agent now has a native edit_file tool on every host: it replaces one exact, unambiguous snippet of a file with new text and reports the changed lines back, instead of rewriting the whole file or patching it through shell commands. Edits keep the file’s line endings and encoding intact, refuse an ambiguous match rather than guessing, and need no third-party service.

The Morph fast-apply editor is still available where a Morph key is configured — it now appears in the chat as morph_edit, alongside the built-in tool rather than in place of it.

New

A dropped model connection reconnects in place instead of restarting the turn

When the connection to the model provider dropped before the agent had produced anything — mid-thought, or before the first word — the whole turn used to stop, and a scheduled retry restarted it a little later.

Now the agent reconnects right there in the same step, up to two more times, and keeps going. The reasoning it had already streamed before the drop stays in the transcript, and only the model’s own answer counts as the turn’s result. Stop still stops immediately, including while the agent is waiting to reconnect; a drop after the agent has started answering still goes to the scheduled retry as before.

Improved

Console evidence after apply_variant says exactly how much was lost

When a page logs tens of thousands of console lines during apply_variant, the agent no longer receives an unbounded (or silently truncated) dump. Every capture lane keeps the same bounded window — the oldest lines from the mount sequence and the newest lines around the failure, with warnings and errors kept in preference to log/info/debug chatter — and the result states what was lost on one line: dropped 12 345 entries / 3.1 MiB (budget).

A console read that fails is now reported as such (dropped … (read-failed)) instead of looking like a page that logged nothing.

New

See every earlier publish of a preview in the Supervisor

Each preview link in an expanded Supervisor row now shows the source revision it was published from (rev 12) next to its Latest / Behind latest edits badge, so you can tell at a glance which build a link opens. When a variant has been published more than once, a N earlier publishes disclosure under the link lists the previous builds — how long ago, which revision, and who published — and each one still opens its own preview in annotation mode, so you can go back to what was shipped before and compare it with the current build.

Fixed

Opening a Supervisor screenshot showed it squeezed into a narrow column

Clicking a screenshot in a Supervisor row’s Evidence strip opened it in a thin strip down the right edge of the screen, with the pass/fail steps taking the space the image should have had, and in the light theme the counter and controls were near-black on the dark overlay. The full-size view now puts the screenshot in the wide part of the screen, fitted to its width so a full-page capture reads top to bottom with the annotation boxes still lined up, with the step list beside it and the counter, previous/next and close controls across the top — readable in both themes. Clicking the dim area around the screenshot closes it, as does Escape or ✕.

Fixed

The agent can no longer write files outside your workspace

Every file the agent writes, edits, or deletes now has to live inside the session’s workspace. A path elsewhere on the machine — an absolute path outside the project, a .. that climbs above it, or a symlink under the project that points elsewhere — is refused with a clear message before anything is touched, and the agent is told to use the shell for files outside the workspace instead.

Reading files outside the workspace, such as the log of a dev server the agent started, still works as before.

Improved

An automatic retry now reads as reconnecting, not as an error

When the connection to the AI service drops mid-turn and the agent schedules its own retry, the session no longer looks broken while it waits. The status pill, the Tasks-panel banner and the plan badge show a spinner with Reconnecting to the AI service… retrying in 42s, and a second line such as Attempt 2 of 4 · connection to OpenRouter dropped that names the attempt budget and the provider in plain words.

The red error styling is now reserved for the case that actually needs you: the retries ran out and the agent couldn’t continue. Before this change a scheduled retry was drawn in the error palette with the raw error text as its tooltip, so a session that was about to recover on its own read as one that had failed.

Fixed

Stop retrying now cancels the scheduled retry

When the agent had scheduled its own retry after a connection to the AI service dropped, the Stop retrying button in the Tasks panel did nothing: the click failed silently in the browser and the retry went ahead at the deadline. It now cancels the scheduled attempt and clears the countdown as soon as you click it.

Improved

Console logs captured during apply_variant now show what was logged, not just its type

When a variant (or the page) logs an object, array, Map or element, the console entries the agent reads back after apply_variant now show their contents — step {step: 3, el: div#x, nested: {…}} [1, 2, 3] Map(1) {1 => 2} — instead of step Object Array(3) Map(1) or step [object Object] 1,2,3 [object Map]. Every capture lane (kernel browser, local CLI browser, in-page capture) renders the same text for the same call.

Very long arguments are cut at 4 KiB and long entries at 16 KiB, always with a visible … so nothing is silently dropped. console.trace entries stay at level log and start with [trace] so they remain recognisable.

New

Expanding a session in the Supervisor now shows a Preview block with one link per Jarvis variant the session has published, labeled the way Jarvis names it (for example V1 Best Value badge). Each link opens the live page with the variant forced on and annotation mode enabled, shows how long ago it was published, and is marked Latest when it was built from the most recent applied edits — or Behind latest edits when newer edits were applied but never published — so nobody reviews a stale build by mistake. A Jarvis session that has not shipped yet says Not published yet.

The block updates as soon as a publish completes; no need to reopen the session or dig the URL out of the chat.

Fixed

Requirement coverage showed 0/N when tests were tagged REQ-req-…

Tests the agent tagged with a doubled prefix such as @REQ-req-badge did not count toward the requirement REQ-badge, so the Supervisor row and the Requirements panel reported requirements as unverified even though their tests passed. Those tags now join onto the requirement they name.

Fixed

Supervisor rows were missing the screenshots QA had already taken

A session whose tests had passed with screenshots could still show No screenshots yet. in the Supervisor’s Evidence strip, so reviewers had to open the QA report or the session to see the result. The strip now shows the assertion screenshots from the session’s latest test run — every Then and the And/But checks that follow it — whether or not the agent tagged the test or promoted its requirements. Carried-over results from an earlier run are still excluded, so what you see is the current build.

When there genuinely is nothing to show, the strip says why: no tests have run, tests ran without screenshots, or the screenshots live in the QA report.

Fixed

A dropped connection to the AI service mid-reply could end the turn instead of retrying

When the AI service dropped the connection partway through a reply, the session sometimes treated it as a final failure: the turn ended with an error and nothing retried it, even though the same request would have worked a moment later.

Now a dropped connection is recognised for what it is and the turn is retried automatically, the same way a rate limit or a provider outage already was. When a retry does resume the turn, the note in the transcript names the provider plainly (for example “OpenRouter”) instead of an internal route identifier.

Fixed

Variant console.log lines now show up while the agent applies a variant

When the agent added a console.log to a variant to see what it was doing, the line never appeared in the apply result: the build removed console.log, console.info, console.debug and console.trace calls before the variant ever ran in the browser, so the agent was debugging blind.

Those calls now stay in the variant and run whenever the agent applies or previews it, and their output is captured in the apply result alongside console.warn and console.error. The published variant is the same artifact — visitors do not see those lines unless the page is opened with ?coframe_debug=1 (or localStorage.coframe_debug = "1"), which is also how you can inspect a live variant yourself.

Fixed

The Design System brief is a site-wide reference, and the agent says when it is missing

The Design System brief that Mark-17 reads at the start of a session now presents itself as site-wide evidence rather than a rule for the element in front of the agent: the computed styles of the element being edited, the organization’s own brand knowledge and what you asked for take precedence, and the agent says so when they disagree with the brief (a 32px page headline is no longer forced to the site-wide 40px). Long conversations keep the full brief in view — when compaction trims it away, the whole brief is re-pinned instead of a note claiming it is “already in this conversation”.

When the Design System cannot be loaded (Jarvis error, timeout, or a missing key), the agent is told plainly that none is available and to derive brand rules from the live page’s CSS, instead of receiving nothing and guessing. A Jarvis key that Jarvis itself rejects as invalid is retired for that session so the next turn stops retrying it. The advisory brand check no longer flags a color you explicitly asked for in your message as an off-palette violation.

Improved

Watch or stop watching a session in one click from the Sessions list

Every row in the supervisor’s Sessions tab now shows an eye button you can click to watch the session, and click again to stop watching it — no more opening the … menu. The eye is highlighted while the session is in your Watching tab and muted when it isn’t.

New

See your teammates' Mine on the Supervisor

The Supervisor toolbar has a new People picker next to Mine / Everyone. Tick one or more people (search by name or email) and the list shows only the sessions any of them took part in, the same as their own Mine. Each person shows their session count in the window and when they were last active. Under Mine you’re already ticked, so ticking a teammate shows both of you.

The picks are saved in the page link, so you can share the view. To go back, choose Mine or Everyone, or press Clear.

Fixed

Listing files from the filesystem root no longer returns doubled-slash paths

When the agent listed files with the absolute prefix / (or any prefix ending in a slash) in a sandbox, every returned path carried a doubled separator (//tmp/x instead of /tmp/x), and later commands that reused those paths acted on the wrong place. Root and trailing-slash listings now return the real paths.

Improved

Branching a chat keeps the agent's tool results and your attached files

Branch in new chat now carries everything the agent can look back on, not just the transcript. In the new session, read_tool_result and list_evidence still reach every tool result recorded before the branch point, and a file you attached is still there — both the original the agent reads by id and the working copy under .agent/attachments/.

Before this change a branched session kept the messages and the workspace but lost the evidence behind them: the agent would see the attachment’s chip and summary but could not open the rest of the file, and earlier tool output was gone.

While the new session is being prepared it opens on the same restoring screen a full session copy uses, with a one-word “Branching…” status; once it finishes you land in the branched chat as before. Messages after the branch point are not carried over.

Improved

Attached files appear in the workspace so the agent can work on them directly

A file you attach that is larger than about 4 KB now also shows up in the workspace under .agent/attachments/, so the agent can open it with its file tools and shell commands — head, wc, grep, awk — the way it works with any other file, instead of paging through it piece by piece. You see the same file in the file tree.

That workspace file is the agent’s working copy: if the agent edits it, the edit stays. The original you attached is kept untouched with the session’s evidence and is what read_tool_result returns. If the copy is ever missing, it is restored from the original on the next turn.

The copy travels with the workspace when you branch a chat.

Improved

Screenshots and attachments reach the model at the resolution its provider accepts, on every deploy

Every image the agent looks at — a view_image screenshot, a composer attachment, an intake image — used to be shrunk to a fixed 2000-pixel edge before any model saw it, whichever model was running and whether the session ran on the CDN, on a local pnpm dev, or on a fork preview. That kept the most restrictive provider happy but threw away detail models such as Claude 4.7 (2576px) or GPT-5.6 (4 megapixels) would have read natively, and local and fork deploys sometimes sent the model a different image than production did.

Images are now sized per model, per request: each one is derived once to exactly the box the current model consumes and cached, the full-resolution original is kept untouched, and local pnpm dev and fork previews serve the same derivative the CDN would. Each derivative is also encoded in a format the model’s provider accepts, so models that do not take WebP (Kimi on Fireworks) now receive their images instead of a rejected request. The context budget prices the image the model actually receives, so a turn no longer under-counts a large screenshot and runs into the window later. Older sessions keep working unchanged.

Improved

Attach large CSVs, logs and other files without stranding the session

You can now attach large text and data files — a CSV export, a log, a JSON dump, a PDF — to a message and keep working. Files larger than about 4 KB are stored once with the session’s evidence instead of being pasted into the message itself, so a big attachment no longer fills the model’s context on its own or leaves a session unable to continue.

The agent sees the file’s name, type, size, line count and its first lines up front, and reads the rest on demand — the full file, or just the lines, bytes or characters it needs — with the same read_tool_result it uses for any other evidence. list_evidence shows attachments by filename. Files of 4 KB or less are sent exactly as before.

In the transcript a non-image attachment appears as a compact chip with the filename, type and size. Small images and videos are unchanged. Attachments carry over when you fork, export or import a session.

If a session was already stuck because of an oversized attachment from before this change, the message now names the file and its size and tells you to start a new session and re-attach it.

Improved

Apply tells the agent when a variant adds content that sits past the right edge of the viewport

After a variant is applied, the apply result now lists any element the variant added whose box extends past the right edge of the browser viewport — with its text, how many pixels are hidden, and whether a horizontally scrolling container would reveal it or nothing scrolls at all. A navigation row wider than a laptop screen no longer passes silently: the agent sees, for example, that “Sale” is 102px past the 1366px viewport inside a scrollable row, and can decide whether that is intended before you do.

The note is informational — it never marks an apply as failed — and content that fits, or a variant that adds nothing, produces no note.

Improved

Deployed-variant QA picks its viewports from your variant's code

When you QA a deployed variant, the agent now reads the variant’s own code to decide which viewport widths to check instead of always using desktop plus mobile. A variant that only renders from 1025px up gets checked at 1024, 1025 and 1026px, at the common laptop and desktop sizes (1280, 1366, 1440 and 1920px wide) and on mobile, so a “reverts to control at a certain width” or “the last item is cut off on my laptop” report is caught before a customer sends it.

To keep the agent honest, the import step also runs a deterministic scan of the same code and hands the agent a list of suggested widths (each with the line of code that motivates it). The agent cross-checks its own set against that list, explains any width it adds or drops, and writes the final set into the QA report. The report also names every page template the variant branches on (for example a modern and a legacy header) so each one is checked.

Variants with no width condition are QA’d exactly as before.

Fixed

A variant that chooses not to render no longer reads as a broken one

Many variants render only when the page qualifies — a wide enough viewport, the right route, an element they can anchor to. When a variant made that call and left control in place, the editor used to wait the full apply window and then report “Variant did not emit variantRendered”, as if the handshake were broken, and the reason the variant gave was lost.

Applying now settles as soon as the variant declines, and the apply result says so plainly: “Variant declined to render: viewport below 1025px: desktop-only variant” (or that it declined without giving a reason). It is a note, not an error — the variant did what its author intended — so the agent is pointed at the page and viewport it applied on instead of being sent to rewrite working code. A variant that genuinely never signals still reports the same missing-handshake error as before.

Improved

The agent no longer rewrites repository history or runs destructive commands unless you ask

When working inside your repository or sandbox, the agent used to occasionally reach for irreversible operations on its own — rewriting git history, force-pushing, deleting branches, hard resets, or recursive deletes — when a request merely mentioned the repository. It now treats those as off-limits unless you explicitly ask for exactly that, and when a request looks like it needs one, it says so and asks first.

Fixed

Shell commands ending in a heredoc or a comment failed silently

When the agent ran a shell command whose last line closed a heredoc (EOF) or ended in a # comment, the command never ran: it came back with exit code 2 and no output, and the agent had to guess why and retry. Writing a config file or a small script with a heredoc is one of the most common things the agent does, so this showed up as extra, wasted steps in many sessions. Those commands now run exactly as written.

Fixed

A turn that ran out of automatic retries stayed dead until someone typed

When a platform interruption kept killing a turn until its automatic retries were used up, the session just stopped: nothing retried it, and it stayed that way until a person sent a message.

Now the session retries once more on its own after a 30-minute cooldown, and the Chat’s progress badge says when that retry is due (“couldn’t continue after 4 tries — retrying once in 30 min”). Sending a message or pressing Stop before then cancels the automatic retry — your message is the retry.

Fixed

Duplicating a session from Jarvis kept the original's experiment and could fail on large sessions

Forking a session as a Jarvis duplicate keeps the duplicate’s own experiment and no longer fails on large sessions.

Before, a duplicate made from Jarvis could come up attached to the source session’s experiment, and duplicating a session with a large workspace could time out without creating anything. The duplicate now takes exactly the experiment and variants Jarvis asked for, and its files and history are copied inside the editor instead of being uploaded again, so big sessions duplicate as reliably as small ones. A publish label you had picked for a variant in the original carries over to the matching variant in the duplicate.

Fixed

A duplicated session no longer opens with the original's old error

When a session was duplicated (for example when Jarvis relaunched an experiment), the copy opened showing the original session’s last error — “the agent loop did not survive a restart” from weeks earlier — and its “Stop”/retry controls behaved as if that old run were still the copy’s own. The copy also showed up in the sessions list under the original’s creation date and activity totals.

A duplicated session now starts idle. The copied conversation and its history stay visible, but the copy’s status, error banner, creation date and activity totals reflect only what happens in the copy itself.

Improved

Brand check recognises every colour the Design System measured, not only the default palette

When the agent writes a style, the advisory brand check compares the colours it used against the client’s Design System. Until now that reference was the default palette and the CTA colours only, so a measured link blue, focus ring, status colour or dark-mode surface came back flagged as “off-palette” even though it was read from the live site.

The check now also vouches for the colours Jarvis measured elsewhere on the site — the semantic roles (link, focus ring, disabled, placeholder, selection, success / warning / error / info) and the dark or alternate colour scheme’s palette and CTA. Declared-but-never-painted values are still left out, and the brief the agent reads is unchanged: the palette it is asked to use stays the same short list.

New

See when you sent each message

Every message you send now shows the date and time it was sent (Sep 23, 2:34 PM), right beside “you” in the message header, in your own time zone. Messages from a previous year add the year too. Hover the time for the full date.

The time is the moment you pressed send, not when the page was loaded, so it stays the same when you come back to a session later.

Fixed

A session interrupted by a restart on our side keeps showing as working

When a deploy, rollout, or platform restart interrupted a running turn, the session briefly reported Failed — interrupted to the Supervisor, the session API, and the Jarvis Mark-17 tab even though the agent was about to pick the turn back up on its own.

What changed

  • A turn interrupted by a restart now reads as Working for as long as automatic recovery can still resume it, just as it does once a retry has been scheduled.
  • Failed is reserved for the cases where nothing will resume the turn: the automatic retries are used up, or the session paused itself after repeated background errors.
Fixed

Browser preview checks the remote browser is still alive the moment you return

Coming back to a session after the remote browser had timed out — a new tab, a reload, or reconnecting after a while away — could briefly show a raw Session not found page in the Browser panel while the preview worked out for itself that the browser was gone.

The session now confirms with the browser provider that the browser still exists as soon as you reconnect, so a browser that expired while nobody was watching collapses to Browser asleep with its Wake button right away instead of after a failed connection attempt. A healthy browser is left untouched.

Fixed

Browser preview recovers from an expired browser in about five seconds

When you came back to a session after the remote browser had timed out, the preview could sit on a raw Session not found page (or a Disconnected chip) for 15 seconds or more before collapsing to Browser asleep with its Wake button — and occasionally stayed stuck until you reloaded.

The preview now confirms with the browser provider about five seconds after it first loses contact, regardless of how many automatic reconnect attempts happen in between, and checks again as soon as the next attempt fails if the first answer was inconclusive. A dead browser collapses to Browser asleep promptly; a healthy browser with a flaky viewer connection is left untouched.

Fixed

Supervisor experiments picker stays open while you tick several experiments

Ticking an experiment or an organization in the Supervisor’s Experiments picker no longer closes it when a session is open below. You can tick, untick and search through as many as you need in one visit; the picker closes on Esc, a click outside it, or the Experiments button.

What changed

  • Each tick reloads the session list, and the open session used to grab keyboard focus again as it came back — which dismissed the picker and stole your next keystrokes from its search box. A session that (re)opens now takes focus only when you are not already typing somewhere else or inside an open picker or menu. Opening a session from its row or with J / K still lands you in its reply box as before.
Improved

Supervisor console: one type scale, tighter controls, readable muted text

The Supervisor console now uses one integer type scale (11/12/13/14 px), 28 px controls with 4 px corners, and readable muted text everywhere small copy appears. The Experiments picker keeps its “Experiments” label at every width so the trigger is never a bare “All”, the permanent “Showing every experiment…” band is gone, rows show a hand cursor and a consistent hover/focus ring, and sessions with no tasks/tests/requirements no longer render a wall of dashes. Participants known only by a machine id show ”?” instead of made-up initials.

Improved

Supervisor filters: pick a whole organization, keep your state on reload, and see why a list is empty

The Supervisor console’s filters now mean what their labels say.

  • An organization is a working-set member in its own right. Ticking “All” on an organization in the experiment picker keeps the organization itself rather than a snapshot of its experiments, so an experiment created in that organization next week is in your working set without re-ticking — and the link you share says “this organization”, not a list of ids. The separate organization checkboxes in the toolbar are gone — the picker is the one place to choose.
  • Experiments and organizations combine as a union. A working set of two experiments plus one organization shows sessions from any of the three; it no longer requires a session to match both lists.
  • State filters survive a reload. The attention states you selected (Needs you, Failed, Review, …) and your organizations are restored on a bare /supervisor, the same way the lens, experiments and window already were.
  • Empty lists explain themselves. When nothing matches, the feed lists every active filter as a chip — Lens: Mine, Working set: 3 experiments, Tier: Review, Active in: last 24h, Search: "cart" — each with an ✕ that lifts only that filter, plus Clear all. Sessions you hid yourself count too: Hidden by you: 2 appears when they are what is keeping the list empty, and Clear all shows them again.
  • Counts are honest. The state chips and the “need you” badge show 12+ while older pages are still unloaded, and their tooltip says the count is of loaded sessions only.
Improved

Supervisor groups and rows name the client, experiment, and variant right away

Experiment groups in the Supervisor no longer open as a bare id such as exp 6a84cf26 that swaps to a name a few seconds later. Each heading shows the client and the experiment slug (with the title beside it) on first paint, so two experiments with the same title in different organizations read differently.

Rows under an experiment with several variants now show the variant’s name, and the page under test moves to its own muted line so the two never compete for the same space — including on narrow windows. Sessions started before this release keep their labels through the previous lookup.

Improved

Supervisor Watching panes open ready to use and say which session they are

Watching a session in the Supervisor now lands you on its chat and pending actions, titled Client · experiment · variant, without a notifications prompt to dismiss first.

What changed

  • Panes in Watching no longer show the editor’s “Enable notifications” onboarding. Opening a session directly at /edit/… still offers it.
  • A new pane opens on the session’s chat and actions. The Browser and Storybook surfaces are one click away in the pane header and are never the first thing you see.
  • The pane header reads Client · experiment · variant (falling back to the target page or session id while Jarvis metadata resolves), keeps the state chip and its elapsed time, and has visible Unwatch and Open ↗ controls — no more hunting for them in a menu.
  • An expanded row in Sessions has a one-click Watch / Watching ✓ button next to Open session ↗; the Watching count updates immediately.
  • The message you are drafting for a session is one draft: type it in the row on Sessions, and the same text is waiting in that session’s Watching card (and the other way round). When a pane shows the live editor instead, a Draft chip tells you an unsent draft exists and switches to the card where you can send it.
Improved

Supervisor: rows that need you show how long the question has waited, longest-waiting first, and the feed no longer reorders under your cursor

In the Supervisor console, a session that is waiting on you now reads Waiting 14m — counted from the moment the agent asked its question or requested approval, not from the last time anyone opened or watched the session. Opening a row to read the question no longer resets its age.

What changed

  • Waiting vs Active. Rows that need you show Waiting Nm (time since the pending question or approval was raised). Every other row shows Active Nm (time since the session’s last activity). The bare age column is gone, so the two are never confused.
  • Longest-waiting first. Within a group and in the Sessions needing you queue, the question that has waited longest comes first; groups with pending questions are ordered by their oldest one.
  • No reordering under your cursor. While your pointer is over the feed or a row is expanded, live updates still refresh each row’s content but hold its position. A quiet N changes — reorder pill appears; click it to apply the new order at once, or move the pointer away (and collapse the row) and it applies on its own.
  • An expanded row stays put. Answering a question with the Needs you filter on keeps the row where it is — dimmed, still open — until you collapse it, instead of vanishing mid-read.
Fixed

Supervisor: the ‹ › stepper over sessions needing you now sits above the list, not inside the open session

The 1 of 2 needing you control used to appear in the header of the session you had open. Because every other thing in that header is about that session, it read as “question 1 of 2 in this session” — and then the session only had one question.

It walks sessions, not questions: pressing › opens the next session that needs you, wherever it is in the list, across experiments and clients. It now lives in its own strip above the list and says so: Session 1 of 2 needing you.

What you’ll notice

  • A strip above the list, not a control inside the open session, with the same ‹ › buttons and J / K keys as before.
  • With nothing open it reads 2 sessions need you, and › opens the first of them (‹ the last).
  • It only shows when something needs you — no strip, nothing to step through.
  • Folding a group still takes its sessions out of the walk, as before.
Improved

Supervisor: the experiments picker now shows organizations as headings, each with an explicit "All N" tick

In the Experiments picker on /supervisor, an organization used to look like one more experiment line — same tick box, same indent, same weight — so it was not obvious that clicking it took the whole customer, or which rows belonged to it.

Each organization is now a heading: its name in small caps on a raised band, the count beneath it (7 experiments · 2 need you, or 3 of 7 selected while only some are ticked), and one labelled All 7 tick on the right that takes or releases every experiment the window knows for it. A partly-ticked organization shows a dash. Its experiments sit indented under the heading with their IDs in one aligned column; a ticked experiment is tinted with an accent edge. Headings stay pinned while you scroll through a long organization.

Folding got keys: with the list open, ← folds the highlighted organization (from one of its experiments too) and → unfolds it. The chevron on the heading still works, and searching still unfolds everything.

Nothing about what the picker selects changed: the same experiments are ticked by the same clicks; the working set applies the moment you tick.

Improved

Supervisor: yes/no questions are two buttons, keys are listed under ?, and Failed rows say what to do

Acting on a session from the Supervisor is more direct:

  • Yes/no questions from the agent show two named buttons instead of a checkbox and a separate Answer step. One click answers when that is the only question; if you have typed a note or attached an image, the click just picks the answer and Answer sends both together.
  • Keyboard shortcuts are discoverable. Press ? (or the keyboard button in the toolbar) for the list: J / K step between sessions, 1–9 pick an option, Enter sends, Esc leaves the answer field and returns to the row so J / K work again. Options that a digit picks show that digit as a small key cap.
  • Failed rows explain themselves. A short line says what went wrong and what to do (for example Sandbox lost — Retry restarts it); the raw error is one click away under Raw error.
  • Idle means someone worked here. Sessions that were created but never used no longer appear as rows; each group ends with one N empty sessions line you can expand.
  • A session with several pending questions says 2 questions in its row instead of Question.
  • The receipt after sending text with an image now reads your message +1 image.
  • On narrow windows the state label no longer overlaps the session title.
New

The Help Center changelog is now generated — with live demos, not screenshots

This page is now built from the release notes that ship with each change, so it stays complete without anyone maintaining it by hand.

  • Every entry is dated the day it actually reached production — the date comes from the deploy itself, so it never drifts.
  • Notes can embed the real component in action (the demo in the Tasks sidebar note is the live product, not an image), so you can try a feature right here before opening the editor. Demos follow the Help Center’s light/dark setting, so what you see matches your editor.
  • Newest changes are on top; New, Improved, and Fixed badges tell you at a glance what kind of change each one is.
Fixed

Typing before you're signed in to Jarvis no longer loses your message

On a slow start, or before your Jarvis key was attached, the composer could briefly be swapped for the Connect to Jarvis card and come back empty — losing your typed message and attachments. The draft now survives.

What changed

  • The chat composer stays in place (hidden, not removed) while the Connect to Jarvis card is shown, so whatever you typed is still there when the key attaches.
  • The connect gate waits for the session’s first state update before deciding you’re not connected, instead of flashing the card during the gap between the page loading and the session waking up.
  • Nothing changes about who can send: a message still needs a connected Jarvis key to go out on deployments that require one.
Fixed

Stop, Skip and Send now take effect immediately — and what they interrupted reads "Stopped", not "Command failed"

Stop, Skip this task and Send now used to wait for the running command to finish on its own — sometimes minutes — and could then resume the stopped work or call the interrupted step a failure. They now land at once.

All three are recorded as your decision, not as a crash or a restart.

What you’ll notice

  • No wait. Stop and Send now kill the shell command the agent is running right away instead of letting it run out; the queue moves on as soon as the transcript is saved.
  • No surprise resume. A stopped turn stays stopped. The recovery that used to mistake a stopped run for a crash and pick the work back up no longer fires.
  • Honest status. The tool the agent was inside settles as a neutral Stopped card. It no longer shows a red Command failed · interrupted by a restart when nothing restarted, and the Tasks panel no longer flashes Couldn’t continue before a skipped task’s continuation starts.
  • The agent is told the truth too: it learns that you stopped the step, that the effect of a command already sent is unknown, and that it should not redo the work on its own.
Fixed

Chat composer controls are legible in light mode

In light mode the composer’s placeholder text, the Stop button while the agent is streaming, and the idle Send button were hard to make out — the send arrow was effectively invisible. All three now meet the WCAG contrast bar in both themes.

New

The Tasks sidebar is now the one place to follow progress — and skip a task

The task plan that used to sit above the chat composer is gone; the Tasks sidebar and the status pill in the header are now the only progress surfaces, and they always agree.

  • The header shows N of T done · S skipped and how long the agent has been working.
  • Each task shows its status, the steps taken, and the files it touched; the active task is highlighted.
  • Skip this task stops the agent’s work on that task right away — it moves on to the remaining ones instead of finishing the turn first. Keep task is the default, so a stray click does nothing.

Try it below: open the task in progress and choose Skip this task — the agent moves on to the next one.

New

Site Config: the browser picks the right location for each site — and tells you why

When a site blocks or degrades the shared browser, Coframe now recommends the browsing location and network that reach it, applies it for you, and explains the choice in plain language from the browser settings gear.

What you’ll see

  • The browser settings gear in the Browser tab opens with Browsing from … and, underneath, a Recommendation for this site section: what Coframe recommends for the page you’re on, why, and — once it’s been applied — Coframe switched this browser to United States to reach www.example.com. Re-check this site asks for a fresh recommendation at any time.
  • Any other locations Kernel found that also work are listed under Other locations that work, so you can pick one deliberately instead of guessing.
  • If a page answers with a bot-protection challenge instead of the real page, the Browser tab shows a This site blocked the browser notice with the recommendation and an Apply now button. Applying restarts the browser in the recommended location; Re-check and This wasn’t blocked are there when you know better.
  • Choosing a location Kernel can’t offer no longer fails with a technical error — the gear names the country that isn’t available and points you back at the list.

The same recommendation the gear shows is what the agent reads through get_browser_settings, so a human choice and an agent choice never disagree.

Improved

Claude Opus 5 is now the default model for Build and Prototype

Sessions that don’t pick a model — including every Build or Prototype session launched from Jarvis — now run on Claude Opus 5 instead of Claude Sonnet 5. The model picker marks Opus 5 as Recommended default.

  • A model you choose explicitly, per session or per queued message, is still honoured.
  • Flash mode is unchanged and keeps its own fast coder and critic models.
Improved

The editor now fits phones, tablets and small laptops — tabs stay reachable at every width

The row above the preview — experiment chip, status, Help, Publish — used to squeeze the tabs to nothing on narrow screens. It now condenses step by step, so you can always switch tabs and reach Publish, phone to ultra-wide.

What changed

  • Tabs first. When space runs out the tab strip scrolls first, down to a floor that always keeps the selected tab and the ▾N overflow button visible; then the experiment chip and status text shorten. Publish, Help, the bell, avatars and fullscreen never shrink or fall off-screen.
  • A condensation ladder. As the pane narrows the chip drops the variant names, then the experiment title, then shortens the status text, then hides the lineage chip and the Help label. Everything dropped is still in the tooltip, so hovering shows the full name.
  • Phones get their own row. On a phone the controls move to a compact row above the panels, giving the tab strip the whole width.
  • The experiment slug and title, and the variant number and name, are separate labels now, so the condensed chip always reads slug · V2 rather than a truncated fragment.
New

Light mode — the editor follows whatever colour mode Jarvis is in

The editor now has a light theme. Inside Jarvis it inherits Jarvis’s own light or dark mode, so a light-mode workspace no longer shows a dark editor island; opened on its own it follows your operating system.

What changed

  • Embedded in Jarvis: the editor switches with Jarvis’s mode, live, with no flash of dark chrome while it loads.
  • Standalone: the editor follows your OS preference (light or dark) and keeps following it if you change it while the tab is open.
  • The light palette is the same one Jarvis’s light mode uses, so chat, the browser panel, the Tasks and Requirements sidebars, the import page and the startup card all match the surrounding product.
  • Preview content (your variants, Storybook stories, brand demos) is not restyled — only the editor chrome around it changes.

Every live demo on this changelog follows the site theme; use the theme toggle in the header to see both modes.

Improved

Components, Requirements and Previews tabs appear only once they have something to show

A fresh session no longer opens with three empty tabs. Components, Requirements and Previews stay hidden until they have content, then appear quietly in their usual place — without stealing focus from what you’re looking at.

What changed

  • Components appears the first time the workspace contains a story file.
  • Requirements appears the first time the agent records a requirement, assumption or open question — and the agent can still open it for you when it needs an answer.
  • Previews appears the first time a preview is ready.
  • Once shown, a tab stays; it is never yanked away if its content is later cleared. Chat and Browser are unchanged and always present.
  • Saved layouts from before this change are cleaned up on load, so the empty tabs don’t reappear from an old layout.
New

Queue follow-up messages while the agent works — they survive reloads and wait for the agent to finish

Messages you send while the agent is busy now queue on the session itself, not in your browser tab: they survive a reload, a phone tab being evicted, or switching devices, and everyone in the session sees the same queue.

How it works

  • Type while the agent is working and press send — the message joins a Queued list above the composer with its position and next runs when the agent finishes.
  • Each queued row keeps the mode and model you chose for it (Build, Prototype or Flash), so a Flash follow-up stays Flash even if you switch the composer back.
  • Hover a row to edit, remove, reorder, or Send now — which stops the current turn and runs that message immediately.
  • Queued messages only go out when the agent has actually finished its turn. They wait if the agent asks you a question, needs an approval, or hit an error — a queued message never answers a question on your behalf.
  • Attachments are uploaded when you queue, so a queued message with screenshots is complete the moment it’s accepted.

The demo below is the real composer bound to an in-memory copy of the session queue — try editing, reordering or removing a row.

Improved

An idle browser is now "Asleep", not a red "Session expired" — and it remembers the page it will reopen

When the shared browser hibernates after a period of inactivity, the Browser tab now says so calmly: a blue Asleep chip with a Wake button, and a readable card over your last screenshot that explains nothing is lost.

What changed

  • The chip in the browser’s address bar reads Asleep in blue instead of Session expired in error red. Sleeping after idle time is the browser’s normal resting state — it saves browser minutes — and it’s presented that way.
  • The card over the last screenshot now sits on a solid panel so it is legible on light pages too, and spells out what you can expect: Nothing is lost, The agent isn’t blocked (it wakes the browser itself when it needs the web), Waking takes seconds.
  • Wake browser on the card or Wake on the chip both bring it back and reopen the page you were editing.
  • The address bar keeps showing the URL the browser will reopen instead of No page loaded, so you can see where you’ll land before you wake it.

Click Wake browser in the demo to step through asleep → starting → live.

New

Edit mode: change a page visually and hand the result to the agent as a prompt

The Annotate menu has a new Edit option: click an element on the live page, change its copy, colours or typography, and save — the agent receives your edits as a precise prompt and makes the change in source.

What you’ll see

  • Annotate ▸ Edit (“Click an element to edit its text and style”) sits alongside the comment modes — Element, Text, Multi, Area — and Walkthrough.
  • Click a headline, button or block to open the style panel; Edit text on page rewrites copy inline. The page updates live as you work.
  • Saving creates an annotation that carries the structured list of operations you made. In chat, the annotation card shows a one-line digest such as font-size: 24px → 32px · text: “Buy now” → “Start free trial”, and the agent is told to make the same change in the source — not as inline styles.
  • Add a note to the edit and the note is placed ahead of the generated prompt; leave it blank and the edit alone is enough.

Below is the real page overlay in Edit mode against a sample page — click the headline, tagline or button to try it.

New

Browser settings: view a site as a macOS, Windows or Linux visitor

Some sites show Mac or Windows visitors a different page than the Linux browser Coframe uses by default. The browser settings gear now lets you choose the operating system the shared browser presents to the site.

What changed

  • The gear in the Browser tab has an Operating system section: Default, macOS, Windows or Linux. Picking one restarts the browser so its very first page load already carries the new identity — the user-agent string and the modern client-hint headers sites read.
  • Default means “whatever the browser natively is” (Linux today). Choosing Linux explicitly pins it, so the choice keeps meaning Linux even if the underlying browser changes.
  • Also pin navigator.platform is an opt-in checkbox for the rare site that reads the older JavaScript platform value. It is off by default because that technique is detectable by anti-bot scripts; the checkbox says so.
  • The choice is saved with the session, so everyone in it — and the agent — sees the same site.
Improved

Requirement changes surface as one card in the chat, so you can see the agent heard you

The agent’s updates to your requirements used to disappear into the collapsed 42 tools fold. They now appear as a compact Requirements card in the chat, with a row per change linked to the Requirements panel.

What you’ll see

  • A card headed ≡ Requirements with count chips such as +1 new, 1 changed, 1 assumption, 1 question, and 1 rejected when a write was only partly applied.
  • One row per change, tagged NEW, CHANGED, REMOVED, ASSUMPTION or QUESTION, showing the requirement’s current title and what changed. Click a row to open and highlight that requirement in the Requirements panel.
  • Only applied changes are shown. Bookkeeping such as status updates stays in the fold, and a change that failed entirely never gets a card claiming it happened.
  • Cards sit between working blocks in the order things happened, so if the agent re-plans after implementing you still see when each requirement changed.
Fixed

Forking a session is fast and reliable — the new session opens at once with a Restoring progress modal

Forking a large session used to freeze on Forking session… for 40 seconds or more and often failed with a server memory error. The copy now happens on the server, and the new session opens at once while it restores.

What changed

  • Fork session and Branch in new chat send a ~200-byte request instead of pulling a 20+ MB export through your browser and pushing it back. The new session’s URL comes back at once and you’re taken there.
  • The new session shows a Restoring modal with live progress — snapshot, import, files (done/total · MB) and verify — an elapsed clock, and, if a step fails, the reason and a Retry restore button.
  • The header shows a Forked from <source> chip so you can tell a fork from its original.
  • The Import page accepts a session URL or id beside the archive drop-zone, with Full / No chat options, so a colleague’s session can be copied without downloading anything.
  • Copies are verified file by file before the session is marked complete.
New

Publish tracking — every publish is recorded per variant, shown in chat, and the agent is nudged when one is due

See exactly what was published where, by whom and when. Every publish — yours or the agent’s — is recorded against its Jarvis variant, shown inline in the chat, and reflected on the variant’s card in the Publish dialog.

What changed

  • Inline publish timeline. A settled publish appears in the chat as Published <build> → <variant> · <time> · rev N · by <name> with a preview link, right after the message that triggered it. The timeline is stored with the session, so it survives reload and reconnect.
  • Redesigned Publish dialog. The header shows the linked experiment with Open and Change; each publishable variant has its own card with Never published, Published 51s ago or Changed since publish · published 1h ago (amber), the last failed attempt if any, and a Preview link. Control and deleted variants are not listed.
  • Publish-due nudge. If the agent applies a change but ends its turn without publishing a variant that has changed, it is reminded automatically. If it still doesn’t publish, the header’s Publish button and the dialog say so, so you can publish by hand or ask again.
  • A publish to several destinations that fails part-way records the ones that shipped as published and keeps only the rest marked as due.
Improved

Tool rows read like actions, not function names — "Edited pricing.tsx · +12 −3" instead of "Ran Edit File"

The steps the agent takes on every turn — editing a file, loading a skill, checking a variant, waiting for tests — now have plain-language labels with the detail that matters, in the rows and in the working ticker.

What changed

  • Edits show Edited plant-based.feature · +12 −3, with the instructions and the code change underneath, instead of Ran Edit File plant-based.feature 6.2 KB. The working ticker now names the file too.
  • Skills read Loaded skill authoring-variant-tsx / Unloaded skill … with the skill’s name.
  • Check variant shows the variant label with clean, N advisories, N errors or build failed; a failed check is marked as such rather than as a successful run.
  • Wait for tests shows the lane and N passed / N failed / timed out — a red suite the agent correctly reported counts as a completed check, a timeout counts as a failure.
  • Browser, preview, task and skill tools that were still falling back to Ran <Title Case> have curated labels as well.
New

Copy any chat message, or branch a new chat from it

Hover any message in the chat and two new actions join Edit, Retry and Delete: Copy message puts the message’s text on your clipboard, and Branch in new chat opens a fresh session that keeps the conversation up to that point.

Copy

  • Available on every finished user and assistant message, including read-only views such as shared transcripts.
  • Copies the text as plain paragraphs — reasoning, tool calls and attachments are left out — and shows a check mark for two seconds.

Branch in new chat

  • Starts a new session with the same workspace and the transcript through the chosen message, then opens it. The original session is untouched.
  • Useful when a conversation has gone one way and you want to try another from a known-good point, or when a long session is running out of context.
  • Only one branch runs at a time; the message that is branching shows a spinner while the new session is prepared.

Hover a message in the live transcript below to see the Copy action.

June 2026

New

Help Center launched

Guides, getting-started walkthroughs, and this changelog now live in one place. Every feature page shows the real interface — not screenshots — so what you see here is what you get in the app.