Repository navigation
- A CAPTCHA Browser Use Cloud is solving is waited on until the solve ends. A bot check was watched for 12 seconds at most, so a solve that took longer ended the run
blockedwhile the solver was still working. Browser Use Cloud reports each CAPTCHA its solver takes on and how the solve ended, and the run now follows that: it waits while the solver works, goes on once the page clears, and stopsblockedas soon as the solver gives up. A page no solver works on, such as a check that runs its own script or one in a browser without a solver, is still watched for 12 seconds (#868). - A release is published only after its evals pass. The benchmark campaign used to run once a release was out. Now the fixture suites and, for a minor release, the full campaign run on the release commit first, and the release workflow publishes nothing until they pass: no task passes less often than in the last release's campaign, and runs are faster and cheaper on average.
scripts/release_gate.pyis the check, and docs/agents/release.md has the steps. - A fixture run can be published as the baseline later runs are compared with. The fixture runner kept no attempt ledger, and publishing requires one, so no fixture run had been published since 0.5.9, under suite names the runner no longer writes. The publication gate therefore found no baseline for any fixture task and never compared one. The runner now writes
<rows>.attempts.jsonlbeside its rows. It never retries, so each row is its own attempt. Each release publishes its fixture rows (#874). - The fixture receipt counts the tasks there are. A release candidate's fixture receipt claimed 108 passing runs, a number written by hand when there were 36 fixture tasks. The receipt now counts every local and mock task three times, which is the count that
checks.fixtureholds the run's rows to (#873). - A total over a CSV file adds its rows. A downloaded CSV is read one row per note, such as
A-1001,Blue Kettle,34.50, and a number next to a comma was not read as a number, so each row was reported as an order with no total and the answer was withheld. A comma also groups thousands, andINV-01,120.00read as 1,120.00. Each row now offers both readings, and Jev picks the one that is the requested field. - An answer rejected for leaving out what the task asks is rewritten, not repeated. Asked for the date a booking site confirmed, the run first answered with the site's own sentence, "Your table is booked for 2027-03-04.", which does not say the site confirmed it. The rewrite was told the claim passed its checks, so it often wrote the same sentence again and the answer was withheld. A rejected coverage check now tells the composer that the claims together, including those that passed, do not give what the task asks in its terms.
- A rewritten answer keeps each claim that passed, word for word. After a rejection the composer wrote the whole answer again, including claims whose checks had passed, and retyped their names: a rewrite named "Clerlsey Grinder" where the note says "Clerkenwell Grinder", which then failed its own check and the answer was withheld. Code now keeps each claim that passed, with its evidence, and the composer writes only the rest. When the answer as a whole leaves out what the task asks, every claim may be reworded. A claim rejected for naming the wrong item is told the item as its note writes it.
- A run with an output schema gets its one rewrite too. A rejected answer was rewritten only when the run had no output schema, so a schema run ended
unverifiedon the first rejection. It now gets the same rewrite, and a schema run that still ends without a checked answer returns the values its extraction found. - DeepSeek requests go to endpoints that copy text exactly. OpenRouter's latency sort sent DeepSeek V4.1 Flash to whichever of about 50 endpoints was fastest, most often Together, which changed words the model copied: the same compose request at temperature 0 came back with "Clerkwell Coffee" for "Clerkenwell Coffee", or a price of "GBP 9.99", in 3 to 6 of 100 replays there. Parasail, DeepInfra and InferenceNet wrote it correctly 100 of 100 times each, so DeepSeek requests through OpenRouter try them in that order and never fall back to Together. Parasail answers at Together's 1.2 s median, and the two fixture tasks that failed this way passed 40 of 40 runs. A benchmark cassette is recorded through the same routing, so its answers come from the endpoints a run is sent to (#871).
- A second cheapest, or any place after the extreme, is worked out in code. A task asking for the two cheapest books had a tally only for the cheapest, so the composer cited one record for the second and the support check rejected it in some runs. A minimum or maximum can now name a place, such as 2 for the second cheapest, and code picks the record at that place among the distinct values. A task asking for more than one place gets one claim per place, each worked out this way.
- A note holding more numbers than one choice can offer still gives its value. A flight results block held 259 numbers, every one offered as a possible price in a single choice. Jev accepts at most 255 options, so it refused the question and the claim's support was left unanswered. The numbers are now offered in groups first and the value is picked inside the group chosen, as a long dropdown's options are.
- The composer sees the headings each note sits under. Asked which heading an embedded email form shows, a run's first answer gave the form's heading, "Send updates to my inbox ...", on its own, and the coverage check asked for it in the task's terms. The rewrite saw each note as bare text, so the form's heading read as any other line, and it sometimes cited the frame's title above it, "Internal IFrame: Email Subscription", instead. Each note now carries the headings it sits under, as the support check's quotes already did.
- A price a page states across many records is not counted as one of them. A flight search's date picker shows "from $348", the lowest one-way fare on that date with any number of stops. Asked for the cheapest nonstop flight, the tally counted that line as a nonstop flight at $348, about 0.72 on each replay, and the correct cheapest was rejected. Asking whether a note is one record now excludes any value a page states across many records, such as a total or a price they start from: the same line scores about 0.25, and real flight results still score 0.75 to 0.98.
- A cheapest or priciest answer can name the record without its value. Asked which shop sells a grinder cheaper, the composer sometimes wrote the shop's name as the tally's value, and code wrote the worked price over it, so the answer read "84.99 sells the Burr Grinder cheaper". A minimum or maximum written as the record's name now keeps it, and code checks that the record it names is the one at the extreme. A count or total written as words is sent back. A worked value replaces only the number the claim wrote, so "GBP 84.99" keeps its currency code.
- A record's name is not read as its price. A tally reads the value a claim writes as a number only when it is one: a single number, beside at most a currency sign or code such as "GBP 84.99". "Galaxy S20 Ultra" was read as 20, and the worked price was written over the phone's model number.
- "Its first Friday" after "next month" is next month's first Friday. A date the task places in a month it names elsewhere was resolved without that month, so the run was given the next Friday from today, 2026-11-13, instead of 2026-12-04. Such a reference now takes the month or the count of months the task names, and a weekday with a place in a month but no month is left out rather than guessed.
- Ads are not read as page text. Reading the text of cross-origin frames brought in the ad frames on a page, so a run quoted an ad's text in its answer. Frames Chrome tags as ads are now left out of the page's text and its effects.
- Recorded fixture runs are the same on every machine. The fixture harness started Chrome in the machine's locale, and Chrome's own messages, such as a required field's "Please fill in this field.", were recorded in it: a cassette filled on an en-GB machine missed on CI, where Chrome writes "Please fill out this field.". The harness's Chrome now always starts in en-US.
- A full head-to-head campaign runs Browser Harness. The campaign workflow installed Codex 0.166.0 while the harness pins 0.163.0, so every Browser Harness attempt stopped before it started. Each failed attempt kept its cost reserve, and the group's budget ran out with about $10 spent. The workflow now installs the version the harness pins, and the harness checks its pinned tools before it opens an attempt's browser, so a mismatch is a refused start that holds no reserve. A failed command's error keeps the end of its output, where the reason is.
- A look at a dense page is back near its old cost. Finding controls with only a click listener (#849) sent a second evaluate with every look that read every element's listeners, and the check for a control clipped to nothing read every element's style and box. Together they made each look 13 to 17% slower. The listener reader is now kept once per document and asked only about the elements a look weighs, and an element's box is read only when it has a clip. A look on the benchmark pages now takes 0 to 7% longer than before listeners counted.
- A cheapest or priciest item read off a sorted list is worked out in code. Asked for the cheapest product, the composer sorted the shop by price and named the first item without a tally, and the support check would not accept that the first item of one sorted page is the cheapest in the shop. The composer now sets a tally for every minimum and maximum, including one a sorted list shows first, so code checks it against every record read.
- A tally's written value is the one its claim writes. Asked for the priciest product, the composer often set the tally's written value to a form the claim did not contain, so code could not find it to replace with the worked price, and the rewrite was told only that the claim did not write it. The composer is now told that written is the value exactly as the claim's own text writes it, with an example, and a claim sent back for it is told to copy the value from its text or rewrite the claim to write it once. A task that failed this way in 5 of 10 local runs passed 10 of 10.
- A field given two values by a task gets the first one first. Told to place an order with one postcode and, if the site rejects anything, with another, a run sometimes typed the second postcode first. The beginning and the end of a typed value are picked apart, and here they landed on different postcodes. The question that then settles where the value ends did not say that the first value comes first, and on the recorded checkout it picked the second postcode 9 times in 10. With that rule it picks the first 10 times in 10, and after a rejection it still picks the second. A commit refused for using such later values also says so now: the refusal was "read the page to check it, or finish", which named nothing to fix, so the run ended stuck. It now tells the run to do what the task asks first, with the values it gives first.
- An answer is checked only for denying a step the run took. The check asked whether the answer "agrees with" the run's steps, and Jev weighed things the support check already covers: an order placed after a rejected postcode, or a count of products, scored about 0.5 and the answer was withheld. It now asks only whether the answer says something was not done, or already existed, that a step may have done. On the recorded runs honest answers score 0.77 to 0.98 and real denials 0.02 to 0.08.
- A fill on an error page no longer reports the error. A step's effect named the page's HTTP status whenever it was 400 or more, so a fill on the page a rejected form left behind read "HTTP 400: destination did not load successfully". Only a step that loaded a document reports its status now.
- An answer that must be written is always written by the composer. Before composing, the run asked Jev of each note on its own whether it was the answer as written, and answered with every note it said yes to. A question about one note cannot tell which of two similar notes the task asks about: asked for the heading of a window a link opened, a run answered with that heading and two headings of the page that opened it. That step is gone. It answered on few tasks and cost a Jev call on every other run that reached it, so a run now makes one fewer call there.
- Text read from an embedded frame stays under the headings above the frame. A page that embeds a form under its own heading, such as an email subscription frame under "Internal IFrame: Email Subscription", was read with the form's text under none of the page's headings: a page read without a browser lost them, and a browser read lost them at the form's first heading. A note of the form's heading then did not say which form it heads, so a claim that the subscription form shows that heading was rejected about half the time. Both reads now keep the frame's text under the page's headings, and a page read without a browser marks it as the frame's.
- An answer's citations are numbered from 1 in the order it cites them. They were numbered by every note the run had read, so an answer from a long checkout cited [124] and [157]. The numbers now count only what the answer cites.
- The PyPI eval task starts on the httpx project page. PyPI now answers a Browser Use Cloud search with an image CAPTCHA, so
httpx-requires-pythonendedblockedon every fastbrowse arm and stopped measuring the agent. It starts athttps://pypi.org/project/httpx/and moves to task version 9, so its results no longer compare with version 8 ones. - A run that loses its browser or model after changing the site ends
error, notunavailable.unavailablesays the same run may pass later, but a run that had already posted a reply and then lost its browser connection said so too, and running it again would post twice. Such a run now endserror, and its error names the steps that may have changed the site and says to check the site before running the task again (#857). - Local Chrome does not connect to an address it was not allowed to load. A run's scope gate fails a request outside the run's origins before it is sent, but Chrome's network prediction had already opened TCP connections to that address, so a host outside the scope could see that a run touched it. Every local launch now switches network prediction off, in a fresh profile and a kept one alike. Remote browsers, such as Browser Use Cloud, keep their provider's setting (#850).
- The extension connects when Chrome starts. After Chrome restarted, the extension stayed unconnected until something woke it, such as opening its popup, so every
--extensionrun in the meantime endedunavailablewith "no browser has the fastbrowse extension connected". It now connects as Chrome starts (#856). - A date the task names is worked out in code. Every decision used to carry today's date followed by a calendar of thirteen months, so that "the first Friday of December" or "the 8th of next month" could be looked up in it. The decision model and the field writer do not count dates reliably, and the calendar made every step's state larger. Now the task is asked once, as its first page opens, whether it names a date. If it does, a model reads only the parts each date states, such as a month, a weekday or "last", and code works out the date. Each step is told today's date and the date each reference means, such as
the first Friday of December: 2026-12-04 (Friday). - A sign-in wall is told apart from a task that needs an account. One question asked whether a page was a sign-in wall and, in the same breath, carved out about nine cases: a sign-in link beside readable content, a login box for posting, a task with no credentials, a public route the run could take instead, and more. The decision model reads such stacked exceptions poorly, so a readable page was sometimes taken for a wall and a wall on the way to public content stopped the run. The page is now asked only whether its main content asks the visitor to sign in, which also holds for a page that is only a sign-in, such as an OAuth login with no form of its own: asked whether a sign-in form took the place of the page's content, the decision model read Wago's login page as content, and the run ended
stuckinstead ofneeds_login(#855). The task is asked once per run whether it needs a signed-in account, gives credentials, or asks about the sign-in page itself. A wall the task needs stops the run as before, withneeds_login. A wall the task does not need sends the run back to take another way. - Counts, totals and cheapest or largest answers are worked out in code. The composer wrote counts in its own words and a decision model was asked whether they held, which it cannot judge: a correct count of one author's quotes across a site scored about the same as one short, and a correct cheapest book was refused for citing only the winner. The composer now marks what a claim counts, adds or compares, and the decision model answers one question per note read: for a count, whether it holds exactly one record of that kind, and for a total, cheapest or largest, whether it holds one with the value compared, then which number in it is that value. A shop's name heading its page, or a link to it, holds no price, so it is not counted as a shop without one. A note from a table says which of the page's tables it sits in, so a task about the second table is answered from that table. Code counts, adds or compares those answers, writes the value in place of the one the claim wrote and cites every record it rests on, including records on pages the composer left out. A record read twice counts once, as does a line read apart from the card it sits in, while the same text twice on one page, such as a row two tables both hold, is two records, and every record tied for cheapest or largest is cited. Such a claim is then not asked whether its quotes support the whole count or ranking, which is code's work: it is asked only whether it states nothing besides that value, and for a cheapest or largest, which record it names, which code checks is one it found there. A claim that fails one of these is told why, such as a total that also lists each invoice's amount, so the composer moves those amounts into claims of their own. A total is asked about as the total of every record of the kind, and a worked amount carries a currency sign only when the value the claim wrote does, so a sign written before the value is not doubled (#818).
- Whether a task's steps are done is asked as two questions. The check before a run ends offered done, not done and refused as one choice, with refused placed last because the decision model leans toward the first option. It now asks whether every step was carried out and, apart, whether the site refuses one, so no option order can end a run short of a step (#808).
- A commit the task makes conditional is checked with one positive question. Before posting on a condition the task sets, the run asked whether the page showed the state in which the task says not to post, or had not been checked, and posted on a no. It now asks, as a choice, whether in the state the page shows the task says to take the step with its values, says not to, or cannot be told, and posts only on the first. Told that the step was conditional, the decision model read an order the task asks for outright, before a condition on a later one ("place the order using NOTAPOSTCODE; if the site rejects it, fix it"), as waiting on that condition, and refused it about half the time. That check, and the checks for a change the site keeps and a condition the task sets, decide at the decision model's own even odds instead of borrowing the threshold for an irreversible action.
- A page that reports a failure is judged on that question alone. A page was taken as failed only when the decision model's reading that it failed beat its reading that it showed a needed fact, two answers to different questions that share no scale. The failure question now says itself that a page showing the content the task is about, beside a leftover loading or error line, has not failed, and its answer stands alone. Whether a page shows a needed fact is asked without comparing it to the notes, since only unread pages are asked.
- A long dropdown offers every option. A select with more options than one decision holds, such as a list of years or airports, was cut at the first 255, so a later answer could not be picked. Its options are now offered in groups first and the option is picked inside the group chosen, as a page's controls already are.
- A fetched page reads a repeated card as one record, as a browser read does. A page read without a browser split each card into its lines, so a quote became one note for its text and another for its tags, and a product card one note per line. The fetched page is now read the way the browser capture reads it: a run of cards that share a tag and class becomes one record per card, with its single link and the facts it only draws, such as a star rating. A table is never read as a card, so two tables of one style still give one row per row.
- A table's rows are written as cells. An answer asked for as a table was written as one line per row with its cells joined by " | ", and code split the line back into cells. A cell holding that separator, or a row with a line break, lost its table and its per-cell checks. Each row now carries its cells as a list, and code writes the row from them.
- An answer no longer denies what the run just did. A run that created a project with a click answered that the project already existed and that nothing was created, because the answer was written only from what the run had read. The answer is now written with the steps that changed the site in view, and checked against them. An answer that still says something was not done, or already existed, when one of those steps may have done it is written again, and it is withheld if it still disagrees. Runs that acted get one more question in the answer's checks (#837).
- A step the site refuses ends the run with its answer. When a task asked for something the site would not do, such as adding an item shown out of stock, every DONE was turned back until recovery ran out, and a correct answer ended
stuck. The done check can now say the page shows the step cannot be carried out. The run then endsunverifiedwith its answer, and the error says a requested step was not carried out because the site does not allow it (#779). - A page whose read did not finish is read again once. A page counted as read as soon as a read began. An empty capture, a read whose model requests failed, or a reply with no usable answer therefore left the page marked read with nothing taken from it, and Read was not offered on it again. A page now counts as read once a read of it finishes, including a read that finds nothing for the task. A read that did not finish is retried once before the page counts as read anyway (#806).
- A step after a navigation no longer carries the whole previous page. Each decision after a page change used to include the previous page's text, offscreen text and controls. They are now included only while the new page looks like a sign-in wall, where the run judges whether another way forward exists; otherwise the step names the previous page's address and title (#805).
- A task that says to change nothing no longer edits the page. Such a run no longer ticks boxes, picks options or types into fields. Jev is asked once per run whether the task rules edits out, and
--authorizedoes not lift that. Typing into a search box is still allowed (#838). - Text inside an embedded page from another site is now read when choosing each step. Before, the run could click a payment or sign-in frame's buttons but could not see its text, so a message such as 'your card was declined' never reached the step decision or the done check. Each such frame's text now follows the page's text under a line naming the frame's site, within the same size limits. A frame that could not be read is named too, so the step and the checks know part of the page went unread (#807).
- A relative date keeps its exact date. A page that shows "3 weeks ago" often holds the exact date in the element's
datetimeattribute, and the reader dropped it, so a run asked for a release date answered "3 weeks ago". Page reading now keeps that date in brackets after the shown text, in both the browser and the fetched reader (#827). - An icon-only button says what it does from its own class. A control with no accessible name, no icon glyph and no description was offered as a bare
button, so a gallery card's revealed edit and delete controls looked the same. Such a control is now named from a class that calls itself a button, such as.delete-buttonorbtn-close. Layout and framework classes never become names (#631). - A value copied from the task keeps its punctuation. Only the letters and digits of each word could be picked, so a reply quoted as
@name ... version.was typed without its@and its final period. Jev now decides whether the punctuation at either end belongs to the value. (#848) - A commit the task makes conditional checks the page first. An authorized run asked to post only if no reply exists posted anyway, because the request was judged from the task alone. Now, when the task makes a commit depend on what the page shows, the run first checks the page. It refuses unless the page shows the commit is allowed. The page can take authorization away, never grant it. (#848)
- A page's embedded frames have loaded before its first step. A navigation counted as settled once the page's own document was ready, so a frame still loading then showed its controls during the next step, and that step's effect claimed them: a fill on a page whose note panel sits in a frame read "showed 6 controls: Home, Shop, Account, Phone, Note, Save note". A navigation or step now also waits for each frame's document to reach DOMContentLoaded, within the same settle deadline (#869).
- A control that only a script listens to is offered. The remove icon on a chosen tag in a Vue multiselect has no role, tabindex or pointer cursor of its own, only a click listener, so it was never offered and a chosen category could not be removed. An element with a script's click, mousedown, pointerdown, mouseup or pointerup listener now counts as a button, read through Chrome's own listener list without a hook the page could see. A container whose listener handles its children's clicks, as React's root does, is not offered while it holds a control (#849).
- A new tab whose setup fails no longer freezes the page that opened it. The run closes a tab it owns and lets go of one it does not. (#658)
- A dropdown or multiselect is named by its label, not by what it holds. A list-style select or combobox was offered under the name of its selected chips or options, so a run looking for "Categories" never found it. (#838)
- Select on a multiple select toggles one option. Choosing an option replaced every selected option with that one. (#838)
- The hidden select behind a tag picker is no longer offered. Pickers such as Tom Select and select2 keep the original
<select>on the page, clipped to nothing, and a run could choose in it directly. The run now uses the picker's own input. (#838) - A control fading in under the pointer is offered straight away. A card's edit and delete buttons that fade in on hover read as invisible at the start of the fade, so they were missing from the observation right after the hover. (#631)
- A hover that reveals icon-only buttons counts as progress. It was counted toward the stall budget as a step that changed nothing. (#631)
- A page read without a browser reads the frames of its own site. A browserless read never fetched an iframe's document, and it reported that no frame was missing, so a run answered from the page's label for an embedded form instead of the form's own heading. It now reads up to four frames from the page's own site, and frames written inline in the page, where each frame stands, as a browser read does. Any other frame is counted as left out.
- A step that did not go through is checked before the run finishes. Asked to start a demo and report the text it loads, a run whose click on Start was covered by an overlay read the site's tagline and ended
complete. The check that every step the task asks for was carried out ran only once some step had been. It now also runs when a step was tried and not carried out. - A task over some pages of a list reads only those pages, and its answer covers only them. A task that names some pages of a list, such as its first five, now reads those pages and stops. Before, it kept paging past them until it was cancelled. The answer leaves out anything read on later pages. If a page in the range could not be read, the run ends unverified and names that page (#824).
- Breaking: captured blocks no longer carry
list_id,list_countorlist_frameless. Nothing read these fields. Stored capture JSON that still has them no longer loads intoBlock, in Python or Rust. Capture is also cheaper, since it no longer walks every list's members (#809). - A fastbrowse process killed outright takes its Chrome with it. On Linux, a run's headless Chrome was tied to fastbrowse only through cleanup code that a
kill -9, an out-of-memory kill or a crash never runs, so Chrome kept running as an orphan. It also inherited every descriptor fastbrowse held open, such as a caller's pipe. Chrome now ends when the process that started it does, and gets only its standard streams. A process forked from one that already launched Chrome, such as an embedder's worker, launches its own instead of hanging. macOS still relies on the cleanup code (#783). - A rejected answer says what was wrong with it. When an answer failed its checks, the run was told only that it was rejected, and so was the error if it ran out of tries. Both now name the claim and the check it failed, such as a total it could not work out or a cell from the wrong column. An answer the support check is evenly split on is written again rather than ending the run, a claim that cites nothing is written again with its sources, and a source the composer names that does not exist is kept and rejected instead of dropped. Before a form task ends, the done check is told what was typed and never sent. A textless link's surrounding text is no longer offered as an answer in place of the text itself, and a clickable card whose only nested controls are hidden can be clicked (#810, #811, #812, #813, #823, #839).
- The extension's popup shows the runs in this browser. Each run is listed with its tab count, elapsed time and page; clicking one brings its tab forward, and each has Stop, beside a Stop all. The popup says whether fastbrowse is connected and links the fix when it is not, keeps the last five runs with how each ended, and names the extension whose frame took a run's tab. A cancelled run's error now says what stopped it: Stop in the popup, Cancel on Chrome's debugging bar, or closing the run's last tab. The CLI guide now notes that other extensions see and can change a run's pages (#826, #828, #829).
- A commit no longer leaves the native library built from the committed sources. pre-commit runs its hooks over a stashed tree, and the
tyhook'suv checksynced the environment first, so maturin rebuiltsrc/fastbrowse/_native.abi3.sofrom the tree without the unstaged edits and left the extension stale for every later run on that checkout, silently, because the file is gitignored. The hook now checks with--no-sync, and a test fails if a hook that runsuvstops passing it (#766). - A link to another site keeps its whole address. A link to another origin was listed as its host and path, so a click that followed it, or a recipe that saved it, joined that to the current site: a DuckDuckGo result for
blog.logrocket.com/xopenedhttps://duckduckgo.com/blog.logrocket.com/x, and its query was dropped. Such a link now keeps its full address (#830). - Runs can use your own Chrome, with no approval prompt.
--extensionruns the task in the Chrome you already use, signed in as you are, through the new fastbrowse extension. Remote debugging switched on atchrome://inspectstops every connection on an "Allow remote debugging?" prompt; the extension needs no prompt.fastbrowse extension installregisters fastbrowse with Chrome, Chromium, Edge and Brave on Linux, macOS and Windows. Each run works in a tab group of its own and closes its tabs at the end. Stopping it from the extension's popup, Chrome's debugging bar or by closing its tabs ends it with the newcancelledstatus, exit 12. The extension relays only page-level commands and cannot read cookies or saved passwords. With no browser connected the run endsunavailablebefore any spend. The SDKs takeextensionandextension_browser(extensionBrowserin TypeScript), and every result gains abrowserfield saying which browser the run drove and how. - A listing with pictures is answered from its text. Book covers and other ordinary images made a page count as drawn, so the run also read a screenshot of one viewport, and that reading named the dearer book in view over the cheaper one the page text held. A screenshot reading that only repeats words the run already read from the page now adds no note; one that shows something the text does not, such as a price drawn in an image, is kept.
- Interrupting a run stops its cloud browser. Ctrl-C or a SIGTERM (from
timeout, a CI cancel or a process manager) used to end the process at once, leaving its Browser Use Cloud browser to bill until the service's timeout. The CLI now stops the browser first, waiting up to 15 seconds, then exits with 130 for Ctrl-C or 143 for SIGTERM. - A run's cloud browser lives up to 60 minutes by default, up from 15. A run longer than 15 minutes used to lose its browser mid-task and end
unavailable. A run stops its browser when it ends, so the longer limit only matters for a process that is killed outright.cloud_timeout_minutesstill sets it. - A control beside a ticking clock can be clicked. A control's freshness check included the text around it, so a Pause button next to a media player's remaining time was refused as out of date on every click while the clock ran. Text the page changes by itself, between two looks with no input from the run, no longer counts; text that changes after the run's own click, scroll or typing still does.
- A task with more than one item searches for the next one. The text typed into a search box was written from the task alone, so on a three-item cart it searched for the first item twelve times after it was already in the cart. The writer now sees the run's steps so far, as page data and never as instructions, and writes the value for the part still to do.
- A page that never loads in a background tab points at
--foreground. A run attached to your Chrome opens its tab behind the current one, and a signed-in profile can hold that tab's navigation for a minute while the same page loads at once in front. The run still ends unavailable, and the error now says the tab was in the background and that--foregroundopens it in front. - Runs can tell whether audio and video are playing. A native player draws its clock in its own controls, out of the page text, so a run asked to confirm that audio plays and then stops pressed Play and Pause until it ran out of steps. Each observation now lists every audio and video player with its name, nearest heading, playing or paused, ended, muted, elapsed time and duration. The decision model and the done check see it, and a read records it as a quote the answer can cite. Each step's result says how it changed a player: a step that starts or stops one also gives its elapsed time before and after, a seek while paused gives the new time, and a Wait while a player plays says how far its clock moved instead of saying the page did not change. (#780)
- Filling a field late in a long run no longer stalls for minutes. When a run's notes outgrew what the decision model takes, each step dropped facts one at a time, measuring the whole set again after every drop. A checkout run with about 1,800 notes spent over three minutes on each field. The notes kept are the same as before, and the cut now takes a fraction of a second.
- An authorized run no longer adds what the task did not ask for. Adding to a cart can be undone, so it was let through without checking it against the task, and an authorized run could add the wrong product or variant. A click that changes what the site keeps for the user, such as a cart item, a saved setting or a submitted form, now also needs the task to ask for it, including undoing an earlier mistake. When it doesn't, the run is told why and picks another step instead of stopping. This adds one question to the safety check an authorized run already makes before such a click.
- A slow browser reply no longer crashes the run. A command whose reply arrived just as its deadline passed could crash the process with "
async fnresumed after completion", losing the result. The late reply is now used as the command's answer. - Refusing cookies never accepts them. On sites without a known consent platform, the browser used to click a banner's only button even when that button accepted all cookies. Now it acts only on a banner it can refuse, and leaves an accept-only banner on the page for the task to deal with.
- "The page doesn't show it" counts as an answer. When the value a task asks for isn't on the page, such as a heading on a page that has none, an answer saying so used to end the run unverified. It now completes, provided the page itself bears it out.
- A task that answers a cookie banner itself gets to answer it. The browser refuses cookie banners before they appear, so a task such as "accept the cookie banner, then send a support request" could never do its first step. Each browser run now asks the decision model, while the browser starts, whether the task answers a consent banner itself, and leaves the banners on the page when it does. Every other run still has them refused. The question costs about US$0.00002 a run, and none when
refuse_cookie_bannersis off. - A counted answer must match the records it cites. Asked how many quotes an author has, the answer could cite six quotes and still say five. When a claim states a count, the decision model now marks which cited quotes are the counted records, code counts them, and a claim whose number falls outside what the model is sure of is rewritten with the right count before the answer is accepted. A quote the model is unsure about can count either way, so a correct total is not rejected over one hesitant reading. A total the page states itself, such as
27 results returned, is taken as stated and not recounted. - An answer read straight from the page is checked against the task. When Jev picked one line of a page as the whole answer, the run returned it
completewithout asking whether it gave everything the task wanted, so a task asking for two readings and a scroll position could finish on the first reading alone. That answer now gets the same coverage check as a composed one, and an answer that falls short is written up again or endsunverified. - A model whose price changes by day or hour still has its limits read. OpenRouter lists some models' weekend and off-peak prices as overrides, and reading one failed the whole lookup of the model's context window and price ceiling. Without the window, an answer over a long run went to the model as one 8.44 MB request, which the provider refused, and the run ended in error. Each override is now read as another price set, and the dearest of them bounds the cost.
- An answer too long for Jev to check is written up rather than sent. When a run picked thousands of notes as its answer, the check that it covers the task went to Jev as one 26 MB request, which could only fail. The answer is now composed straight away instead.
- A long task's search terms reach the search box. On a 330-word request that named its city once, the task was cut into 166 four-word fragments to pick the city from, none of them looked like a place, and the run searched for nothing. A long task is now cut into four broad parts, and when none of them holds the field's value, the value is written from the task instead of being left empty.
- A run is not done until it has done what the task asked. Asked to sign in and then report the account's email, a run could read the email off another page and end
completewithout entering the sign-in code. Before a run that acted ends, Jev now judges from the steps taken and the current page whether every step the task asks for was carried out, and the run goes back to work if one was not. - A page that stops answering ends the run
unavailable. When a tab stopped answering while its browser still did, the run spent its time retrying commands the page would never answer and endederror. It now endsunavailableat once, and the error names the page that did not answer. - A tab an authorized payment was sent from stays open. When the run ended right after an authorized irreversible click, such as Pay now, it closed its own tab and aborted the payment still redirecting there. A tab an irreversible action was sent from is now the user's, and the run leaves it open in an attached browser so the result page can finish and be checked.
- A value typed into a form field no longer takes in the request around it. Asked for a customer name in "Order a large pizza with mushroom for Ada Lovelace", the agent sometimes typed the whole phrase from "large" onward and submitted the order under it. Once it has found where a value ends, it now asks again where the value begins, choosing between complete values that end there.
- A page whose script stops answering is reported as unresponsive in about 20 seconds instead of two minutes. A click that started an endless loop in the page used to wait out the 120-second command limit before failing. A command sent to a page now checks after 10 seconds whether the page itself still answers. A page that is only slow, such as one waiting on its server, is still waited for in full.
- A runaway model reply ends in about a minute instead of six. Requests through OpenRouter and the Vercel AI Gateway now cap a reply at 32,768 tokens, reasoning included. That is far above anything fastbrowse asks a model to write, so only a degenerate generation reaches the cap: one compose call wrote 131,072 tokens over six minutes before it ended. A reply cut off at the cap is asked once more, as before. Other servers get no cap, since some refuse the field.
- A control is named by what it shows. A name taken from a control's content skipped only
aria-hiddenchildren, so hidden ones counted too. Every AliExpress search result was offered asReport fraud item <product>because of a hidden report button inside each card. That is a different action, and under--authorizea misleading one. Hidden and transparent content no longer counts, and an element named througharia-labelledbyis still read whole. - The skill explains how to reach an everyday Chrome the user names. When remote debugging is switched on at
chrome://inspect, Chrome serves no/json/version, so--cdp-portcannot attach. The browser access guide now says to build thews://address from the profile'sDevToolsActivePortfile and pass it as--cdp-url. - A rejected answer is rewritten from the notes it should cite. When a check rejected a composed answer, the rewrite was shown the rejected claim's citations as internal ids that named none of the notes in front of it, and was told only to keep what passed. It copied those citations back, so an answer naming the most expensive book still cited only that book's price and was rejected again. The rewrite now sees the citations as the notes it is given and is told that a rejected claim must cite every note a comparison, count, total or superlative rests on.
- An answer that passes every check ends complete, even after earlier drafts were rejected. A run asking for the most expensive Travel book had two drafts rejected for the wrong price, and the answer written as the run stopped then passed its claim and coverage checks, yet the run still returned it marked partial and unverified. That answer now ends the run complete. Reading the page a run opened on before leaving it may also find nothing the task needs, so that read no longer withholds the choice to say so, which had forced a guessed answer from a category list.
- A count across a site's pages starts from the page the run opened on and no longer circles back to one record. A run counting one author's quotes left the first page before reading it, then followed that author's "(about)" link from every page because the hint naming links to pages already read listed them by label, and every quote's link reads "(about)". The start page is now read before an action leaves it, and each link to a page already read carries its own mark. An answer composed across pages is also written up again rather than returning one page's pick verbatim, which had answered a count with "Quotes by: GoodReads.com".
- An action that left the page unchanged is not sent again, and a navigation during the settle wait counts as a change. An authorized click whose effect never appears is sent once rather than three times, and a navigation that starts while the action's request is still open counts as a change, not a no-op. Both are now covered by tests (#516).
- A field the form drew again keeps what was already typed into it. What a fill wrote was remembered by element id, so when a rejected form redrew its fields, typing the same value back counted as progress and a checkout run retyped one postcode four times. A field is now known by what the page says it is, and a refill that lands where the first fill landed is no progress. A field the browser refuses also carries the browser's validation message to Jev, which only the browser's own bubble showed, so a run no longer refills the postcode while the form is complaining about an empty Last Name (#548).
- A search that reloads its own page no longer loops on typing the same value. What a fill wrote was remembered per document, so a search that reloaded the same results address forgot the value just typed and counted retyping it as progress, about eight times on one apartment search. The memory is now kept per page address, and the hint says what the field shows instead of claiming it already holds the value (#638).
- A form whose properties are not text no longer ends the run as a browser error. A field named
methodmakes the form's method return that field, and on a React page the field points back at itself, so turning the form's submission into text threw and the run endederror. Only text is kept (#647). - Controls a page renders only under the pointer can now be reached. A media page rendered each image's delete button only while a pointer was over it, so the run had nothing to act on and reported an image it could see as not found. A list card that shows a picture and holds no control is now offered as a hover target, and hovering alone no longer counts as carrying out a task (#631).
- A run that gives up on a drawn page it could not read now says so. A canvas or picture page whose screenshot answered nothing ended
stuckwith the same words as a stall on a readable page. The error now names it, and the troubleshooting guide covers the limitation and the screenshot fallback (#586). - A task about how a page looks can be answered from its screenshot. A theme check on a page styled only by CSS never had its screenshot read, and the image reader only copied text, so the run asked for text evidence of colours until it ran out of steps. Jev now says whether a task is about appearance, and when it is, the screenshot is read and described at the end (#690).
- Jev can wait for a page that changes by itself, so a task that reads a value, waits and reads it again now finishes. No step let time pass, so every read saw the first value and the run never finished. The wait ends once the page changes, at most the settle bound every action already has, and the run's time limit still applies. A wait that changes nothing counts as no progress, and recipes never keep one (#678).
- Replies through the AI Gateway now follow the response schema even when the serving provider ignores it. The gateway cannot require providers to honour the schema, and DeepSeek replies served that way answered
typewhere the schema sayskind, failing validation and its repair. Requests on that route now also state the schema in the prompt; OpenRouter and direct endpoints are unchanged (#541). - Each page a citation quotes is kept as a
captureartifact, and its evidence names it incapture_artifact. A citation named only the digest of the page text it was cut from, and that text was gone after the run, so a quote could not be checked against its source. Captures go where downloads go, so passdownloadsorartifact_sinkto keep them past the run (#617). - A calendar day is offered without its week's other days as its context. A table row's cells are one line of text, so with no month heading a day in the week "26 27 28 29 30 1 2" was offered with the other six numbers as the context that should tell it apart, and a date picker read as if every day were another. A line made only of the labels of the control and its peers no longer names it (#648).
- An answer reports the results the run filtered to, not the ones it read before. Changing a filter changes the page's address, so the unfiltered and filtered results were both kept as current notes, and a flight search that applied a nonstop filter answered with the unfiltered count and a connecting fare. The notes the answer is written from, and the checks on each claim, now name the page each note was read on in reading order, so the later filtered view can be told from the earlier one. A view that changes only the address fragment now retires the earlier read when composing too, where it had been brought back as current (#720).
- Recorded model responses keep negative or non-finite provider costs unknown, preserving valid zero-cost receipts.
- A completed run can be replayed as a recipe.
--save-recipe FILE(save_recipe=in Python) writes the steps acompleterun took, each kept by its page and by what its control means: role, label, context and link, never a selector or a node id.--recipe FILEreplays them. Jev decides on the live page. When its action matches a saved step, the step can reuse saved values through the same freshness, hit-test, authorization and secret gates. Different tasks are refused; different page addresses or controls are decided live. A recorded HTTP or HTTPS start is used when no start is supplied; non-web recipe starts are refused. Reading, answering and the check forcompletealways run live, so a replayed run never reports evidence from an earlier one. Live reading decisions do not consume or abandon saved browser actions. A live choice can reuse a later matching step even when an earlier action is still offered, and replay does not use an arbitrary lookahead or miss cutoff. A secret is kept by name only, and text typed into a sensitive field is not kept. Steps whose page address or control metadata reveals a resolved secret are omitted. Naming the same file for both flags repairs the recipe after a run that had to decide steps itself. Replayed steps reportdecided_by: "recipe". Python embedders can validate recipe JSON with the file loader's Rust parser throughfastbrowse.recipes.validate_recipe()and export its schema withrecipe_schema(). - Recordings show where the agent acts.
--recordvideos now draw a cursor that glides into each click, fill and hover, stays there until the next one, and pulses on clicks. It needs no desktop overlay, so a headless or cloud run shows it too. Secret fields remain unmarked. - Local runs can set their CSS viewport.
--viewport WIDTHxHEIGHTapplies reversible desktop viewport emulation before the first observation on an owned local Chrome; handed browsers reject it and cloud runs keep their existing screen-size behaviour. - A synthesis read reports the source material it kept. After collecting notes for a composed answer, the next decision was told that nothing answered the task. The read now distinguishes source material awaiting composition from an empty read, leaving Jev to judge whether the task is done.
- A PDF opened in a new tab is captured before its viewer loads. Popup adoption waited until after the first response, losing the document text even though direct navigation read it. New pages now wait for download capture before starting; unrelated tabs are resumed and left alone.
- A step-limited run can report the notes it collected. A task needing a composed answer returned no answer when its browser steps ran out. Final reporting now uses those notes while keeping the original budget status and enforcing the remaining dollar, time and model-call limits.
- A slow page is waited for instead of restarted. Behind Browser Use's proxy, DTE Energy's scripts took 35 s each and its page became ready after 45 s, while each of the four navigation tries waited 15 s and then loaded the page again from the start, so no try ever finished and every attempt at the task ended
unavailablebefore its first step. Each try now waits twice as long as the one before, so a page that is slow rather than stuck is ready on a later try. - Eval attempts have no time limit. Publication required every attempt to have stopped at 10 minutes and scored one still running then as DNF, a failure. That limit was set by the eval harness, not by any benchmark or provider: a Zara listing task that reached 600 s with its answer half composed counted as failed. Publication now refuses a run that records any time, step or spend limit, as Parallax sets none.
- A PDF is read as the text it holds. Chrome draws a PDF in its own viewer, whose text never reaches the page, so a run on DTE Energy that opened its renewable project map read only the viewer's toolbar and switched between tabs until it stopped with no answer, though every wind and solar farm on the map is text in the file. A PDF, whether shown in a tab or downloaded, is now read as a downloaded text file is: the run sees its text and cites the file. A scanned PDF, which holds only images, still reads as empty.
- A task that asks for a table gets a table. The composer could only write cited sentences, so a task asking for "one table" of Zara products with their colour, shape, fabric and graphics came back as one sentence per product, and the BU Bench judge failed it for having no table. The composer now names the columns when the task asks for a table and writes each claim as a row; the answer is a Markdown table with each row's citations in a last column, and an answer whose claims are not all rows stays as written.
- A run that must compose its answer still answers when its time runs out. A listing task that read product pages on Zara reached its 600 s limit with facts such as each product's composition in its notes, and returned no answer at all, because writing the table from them needs one LLM call and the clock had already stopped the run. A run whose answer is composed now stops browsing a tenth of its time limit early, at most 60 s, and writes a partial answer from what it read, still marked
budget_exceeded. - A listing says which of its products were already read. Zara's search cards link to a product's address and the site redirects each one to that address with a colour query added, so the read page never matched its card, and a single-page app routes every page through one document, so leaving the results for a product marked the results as changed. A run asked for every women's jersey product opened the same two cards for 42 steps and reread the unchanged results each time. A link the run followed now leads to the page it landed on once read, a read is kept per address within a document, and only an action that leaves the page in view changes it.
- A page that reports its own data requests failed ends as that failure, not as
needs_input. USITC's DataWeb saidHttp failure response for ...: 0 Unknown Errorfour times while offering a control labelled "undefined"; Jev read the page as a site failure, and the run still asked the caller for a value, because a missing field outranked the failure. A failure standing on the page the run is on now ends it; a missing value on a working page still endsneeds_inputwith the field named. - A page number drawn as focusable text is offered as a button. Zara draws its listing's
VIEW 1 2as text whose click is a script listener, with no role, no href and no pointer cursor, so the run could not reach page 2 and answered with page 1's five products. A focusable element whose whole content is its own text is now offered and pressed; a focusable container with element children is not. - A trace keeps an image by name, not by its bytes. With the viewport now sent on drawn pages, recording each request whole wrote the PNG's base64 into the trace: one Street View run's trace was 102 MB for 51 steps and no tool could read it. The asset name (its pixels' digest) and a placeholder stand in, as the eval replay already keys them.
- An image's capture line says what the image is, not that its pixels are undescribed. A read cut the sentence
Pixels are not described.as a span and made it the answer: a Street View run returned 33 citations of that one sentence over a task about what the view shows. The line now carries only the image's alt and source, with the absence of pixels as data. - A site whose certificate the browser refuses ends
unavailable, noterror. A portal serving a chain Chrome rejects stopped a run at its first page, reported as fastbrowse breaking rather than the site not delivering. A certificate or TLS failure is now classified with a refused connection, so the run says the site gave nothing; a mistyped address still ends a plain failure. - A page whose content is drawn is shown to Jev as an image. A map, a photograph or a canvas keeps none of its content in the page's text, so a run asked for a price shown in Street View only had the map's rotate arrows to work with and turned them for 45 steps without ever seeing the imagery. The viewport screenshot now goes with the step's ask when the page reports drawn content, on a route that takes images and never while a secret shows.
- An answer whose value is only in the page's pixels is read from the screenshot. A Street View run reached the imagery but the text layer carried nothing to quote, so it left the panorama and answered "No Street View imagery available here" from the photo gallery that replaced it. When a page reports drawn content and nothing read answers the task, the viewport screenshot goes to the model writing the answer and the value it reads is cited against the screenshot's digest, marked as read from the image rather than as literal page text.
- A drawn page's answer is read even when the run stalls before answering. The screenshot read only ran when a run reached its answer, so a Street View run that turned the view for a price instead ran out of recovery and ended with no answer, the reading never taken. The same read now runs before a run gives up on a drawn page, so a stalled run still reports what the screen showed.
- A calendar day is no longer named after another day. IDOS's date picker is a grid of bare day buttons, and each was offered with the neighbour's number as its context (day 26 named "31", day 3 named "7"), so a run could not tell which month it was picking and walked the grid. A line that is another control of the same kind now names no section, while a card's title still names its card.
- A form whose own properties are not text no longer ends the run. Coursera's React app left an HTML input where a form's method belongs, and the snapshot serialised that field as if it were text, so
JSON.stringifythrew on React's circular fiber and the run ended as a browser error 29 seconds in. A submit's label, method, action and text are now kept only when they are text, which is all a caller can use, and the same task runs to an answer. - Typing the same value into a field again is not progress. A date picker redraws its day grid on every keystroke, so writing the same date a second time changed the page and was credited as a step; on IDOS a run wrote one date four times and spent its recovery budget on the picker instead of the date it needed. The same text into the same field is now one step, whatever the widget redraws.
- A run that needs a field value says which field. When the recovery budget ran out while a field the task gave no value for still stood on the page, the run ended
needs_inputwith the stall's own reason,no_progress (3), and no field named, so the caller had nothing to supply before running again. The error now names it:'Teď' needs a value the task does not give: no_progress (3). - A date field is written with its year. The writer that fills a field the task does not state word for word was given the task and the field's label but not today's date, so "the next upcoming 8 July" became
8.7., which a timetable site read as this year's 8 July, already passed, and the run searched the wrong day. The fill ask now carries today's date and the calendar after it, and a day and month the task names without a year is their next occurrence. - A run no longer flips between two tabs. A tab a click opened was shown while still loading, so it looked empty with nothing to follow, and every switch marked the tab it left as changed since it was read and listed the other tab's controls as new. On Spain's public job portal a run spent its steps switching back and forth. A switch now waits for the tab to load, leaves the tab it left as read, and is reported as showing that tab.
- A search box gets a query, not the task's first word. A field's value could only be words copied from the task, so on a long task whose search terms are not written out (Spain's public job openings, searched for on a Spanish site), Jev picked the first word, and the run typed "I" into the search box fourteen times. Jev can now say the value is written rather than copied, and the LLM writes it from the task and the field's label alone, never from the page. A value the task states word for word is still copied.
- A page read over HTTP keeps the rows of a table inside a table. Hacker News lists every story in one cell of its page table, and the reader flattened that cell into one row, so asking for the top story's title returned all thirty stories. A table inside a cell is now read as a table of its own.
- A placeholder page ends
unavailable, notstuck. A site serving a stub with one line of text and no links, such as KFC Pakistan's from outside the country, left the run scrolling a page with nowhere to go until it endedstuck. Jev is now told when a page offers nothing to follow, and a placeholder served in place of the site counts as a site failure, so the run says the site did not deliver. - An Access Denied page ends
blocked, notneeds_login. A site refusing the visitor outright, with no way to sign in, was read as a sign-in wall, and the result told the caller to pass a password. Jev's bot check now covers a refusal of access, and its sign-in question says such a page is not a sign-in wall. - One slow frame no longer ends the run. A page that did not draw within two seconds of an action ended a cloud run as
error. The step is now recorded as failed and the run looks at the page again. - A long read no longer overflows the LLM or comes back as megabytes of evidence. Composing an answer from many notes sent them all in one request, past the model's context window, and the failed compose returned every note as the answer: 7 MB on one Facebook Ad Library task. Notes are now sent in as many requests as the window needs, none dropped, and the parts' claims are combined; a failed compose returns only the notes Jev marked as answering, or no answer.
- A password field on a page read over HTTP opens the browser. A sign-in form reached before the browser ended
needs_loginwith the secret never tried, because a fetched page cannot say which site a field belongs to. Any fill on such a page now carries on in the browser. - A fill costs one Jev request. What a value should be is asked beside the decision, so filling a field no longer waits on a follow-up request. Whether a press commits anything is asked apart from the page's text, so a page cannot talk the agent into a commit, which costs one more small request on a click. A step sent with a screenshot, or one that would pass the 32,000 bytes where a request turns slower and less accurate, still asks them afterwards. These questions now see the same page state as the decision, and page text stays marked untrusted.
- More cookie banners are refused before they paint. The bundled DuckDuckGo autoconsent moves to 17.2.0, with 504 consent rules where there were 238.
- An answer already on the page comes back without the LLM. When a task picks a winner or names a value and the notes state it, Jev picks those notes as the answer, which takes about 0.2 seconds where writing one took about 2. Anything that has to be counted, added up or put into new sentences is still composed.
- A step costs one Jev request. What a value should be and whether a press commits anything are asked beside the decision, so an action no longer waits on a follow-up request. A step sent with a screenshot, or one that would pass the 32,000 bytes where a request turns slower and less accurate, still asks them afterwards. These questions now see the same page state as the decision, and page text stays marked untrusted.
- A run reads what it has already seen and finishes what the task asked to be told. A done with nothing read, on a task that wants an answer, now sends Jev back to work rather than ending
completewith none. Jev is told which links lead to pages already read, so a paged list ends when every page is held. A page Jev rates more likely to hold evidence than not is read even when no single option outranks "absent". Jev's latest read decides whether an answer needs writing, so one fact that alone answers the task needs no compose. A form's rejection of a value no longer reads as a site failure. - Split code boxes can be filled. A field's
maxlengthis observed, a value longer than it is offered to Jev in pieces of that size, and a span too long for the field cannot be typed into it. A multi-word value's end is asked again knowing where the value begins, also when it was first picked before the beginning, which had left the field unfilled as if the task gave no value, and a field's value question hears what was already typed there. - A failed page ends as that failure, and a stalled run stops sooner. A run that said done on a 404 or error page with nothing read ended
completewith no answer, and a transient failure page could read as an empty result. Both now endstuckwith the page's failure, and an error page's text is no longer read as evidence. A stall ends after one recovery instead of two: in recorded runs a second recovery never rescued one. - Jev decides, reads and finishes, and a run tries HTTP first. A run no longer plans requirements, guesses a shortcut address, recovers through an LLM, or has a done check and verifier overrule Jev's DONE. An LLM is called for two things only: a first address when no
startis given, and an answer Jev says must be composed from more than one fact. Both usedeepseek/deepseek-v4.1-flash-1017by default, in place ofgoogle/gemini-3.8-flash. A run now reads over HTTP, follows links there, and starts a browser only when a step needs one, carrying on from the same page with what it has read;browser(--browser) starts one from the first step and replacesfetch_first. Removed from the protocol:requirement_id,StepResult.fallback, theescalateoperation, thellmdecider and fact reader, and theplan,read,field_text,recoverandshortcutLLM purposes. The protocol version is now 2, so a client and afastbrowsebinary on different versions refuse each other atinitializeinstead of failing mid-run. - Only Jev finishes a run, and only a stall ends one on a give-up. When Jev was unsure of its next step, the recovery model could tell the run to finish, and the run stopped there on a page that still owed work. It could also give up while the run was still moving. Recovery now never directs a finish, and a give-up stops a run only when it has stalled or needs something from the user.
- Jev is told what scrolling has not kept. A run could scroll a long list hundreds of times and lose it all when the browser ended, because each scroll counted as progress and nothing was read. Jev now sees how many scrolls have passed since the last read, and that the notes hold nothing from them.
- A suggestion list left open no longer blocks the next field. A list an address or search field opened could lie over the field below it, and the control was refused as covered again and again while Escape did not close it. When a control is found covered and focus is in a suggesting field, focus now leaves that field, as moving to the next field would, and the control is checked again. A cover that stays is still refused.
- A control the page styled or scripted is offered. An element with no link target and no role, pressable only through a click handler or a pointer cursor, such as a bare
<a>used as a Load more button, was left out of the controls Jev sees. Any element that declares a click handler, or where the pointer cursor starts, is now offered as a button unless it sits inside a control or holds one. - A benchmark attempt stops at 10 minutes and counts as a failure. Every agent on every suite has the same limit, and an attempt past it is stopped with its browser and shown as did not finish. Browser Use Ultrafast now runs all 47 of the 53 live tasks it can attempt. Browser Use and Browser Harness figures come from one checked-in reference, labelled with the date they were measured, refreshed with the
refresh_competitorscampaign input. Config(step_choices=True)records the fallback that took a step off Jev's pick, and why.choicessaid what Jev was offered and which control it chose, but a step the run reached through recovery reported only the step it took, so the decisions Jev was least sure of were the ones with the least recorded. Such a step now carriesfallback: the reason recovery was given, Jev's own certainty on the pick it set aside, and that pick's label. Off by default withchoices, and a step where Jev's pick stood has nofallbackkey, so existing JSON output is unchanged.- Official benchmark results can reach the site. The site shows fastbrowse's measured figures beside Browser Use's own published ones, labelled with their judge. A finished
official-benchmarks.ymlrun leaves public rows (opaque task ids, scores, seconds and dollars, never BU Bench's decrypted goals) thatbenchmark-campaign.ymladds to its candidate throughofficial_runs. Campaign ledgers and official runs now go to the private Langfuse project from a CI step, even when a run stops early. The site's two live suite groups, head-to-head and fastbrowse alone, each get their own card. A release now runs the official suites first and starts the campaign when they pass, so every group lands in one candidate. - Jev gets a screenshot on every Browser Use Cloud browser. The service may pick a screen 1920 wide, past the 1568 pixel side Jev takes, and the screenshot was then dropped without a word. A browser now starts on a 1120 by 780 screen unless
viewportnames another, and a capture on a high density screen is shrunk to fit. - A Browser Use Cloud proxy cost says it has not settled. The service meters proxy data about 30 seconds after a browser stops, so the line a run reports could read $0 or part of the charge while calling itself metered. The line now has the new basis
unsettled, and a run still returns without waiting for it. - A typed value is not taken for a sent one. A read of a filled form quoted the value beside the form's unpressed button, and a run could end complete with nothing sent. Jev and the done check are now told which fields hold a value no action has sent, and the run presses the form's control.
- Cloud browsers start on the Browser Use V4 API. Every Browser Use Cloud browser is created on V4 with its residential US proxy and CAPTCHA solving asked for by name, so a run no longer depends on the service's defaults or an older API.
- The Browser Use Cloud browser is the default everywhere.
run_taskin Python and Rust, like the CLI, MCP server and SDKs, now starts a cloud browser when no browser is named, and needsBROWSER_USE_API_KEYto do so. This breaks a script that relied on local Chrome by default: passchrome=LocalChrome()in Python,local: truein Rust, or--local. - OpenRouter is the recommended route, and comes first. One
OPENROUTER_API_KEYserves Jev, images included, and the LLM. With both keys set, Jev now starts on OpenRouter rather than direct TypeSafe;FASTBROWSE_DECISION_SOURCE=typesafepicks direct. cloud_allow_resizingis gone. Browser Use documents resizing as less stealthy, andviewportalready sets a cloud browser's real screen size.- Jev picks a list's next page. The agent no longer works out a numbered next page or clicks a pager itself. A next-page link is shown to Jev as a fact beside the other links, Jev picks the step, and Jev places each page of a list it reads, so a page outside the list gets an ordinary read. Page caps are gone with it, and
Config.max_pagesno longer exists. - A date is given with its calendar. Each run sees today's date and weekday and a plain calendar from this month to the same month next year, the span where a month or weekday named without a year next falls, so a relative date is read off the calendar rather than worked out.
- A failed
untilcondition is told as the caller's check. A run that met its completion check but failed the caller'suntilcondition reported that Jev had rejected DONE. It now says theuntilcheck failed. - A recovery that gives up stops the run. When the recovery model decided a page was a dead end, the run kept stepping. It now stops with that diagnosis.
- A fragment of a choice no longer counts as showing it. A field holding part of what was typed, such as "Lon" on the way to "London, United Kingdom", counted as set, and the history Jev reads said so. The field must now show the whole choice or its first comma-separated part.
- Every loopback MCP address is protected. The MCP HTTP server checked the token,
HostandOriginonly on some loopback addresses, so127.0.0.2and[::1]went unchecked. They now get the same checks. - A percent before a multibyte character no longer panics. A URL with
%directly before a non-ASCII character now keeps the%as text. - Rules fitted to single tasks are gone. The planner no longer says what a reported order total is, Jev's target rules no longer give a flight-search example, and the reader, answer and partition prompts no longer carry one task's definitions of request, problem report and reply. Jev's short-fact read took only passages scoring 0.6 or above, a bar fitted to one page; it now gets every passage that fits Jev's limits, best scored first. A step that does not fit no longer has its labels cut to 80 characters and its links to 120: it goes to the reductions sized from Jev's documented limit, so a dense page on the 32k budget offers its best scored controls at full length. The date a run sees is today's date and weekday with a calendar of the surrounding weeks, in place of the next two month names and the field writer's seven-day list, and every control without a context now gets its nearest section heading, not only date inputs.
- Jev sees which requirements the notes answer. The notes cite requirements by id, which Jev could not match to the requirements it saw as text, so with an answer already read it kept reading and scrolling until the run stalled. Each requirement now carries its id and whether the notes answer it.
- A page is read once until it changes. Jev's read assessment overrode its pick of a list's next page with another read of the page just read, so multi-page tasks stalled on their first page. The assessment is no longer asked of a page read and unchanged, scrolling does not count as a change, and Jev's own pick stands.
- DONE reads what it would leave behind. A DONE on a page Jev judged to hold unread evidence now reads it first, and a page the run never read is left out when information requirements are judged, because the answer is written from the notes: a comparison no longer passes on a price only that page showed. The done check is also told when the reader saw a list go on past what was read, and a read off that list does not close it: Jev says whether a page that shows no more is a later page of the same list.
- A record keeps a value it only draws. A value shown by a textless element, such as a row of icons a class colours, is captured by the page's own label or class, so a reader can see it.
- A sign-in form takes the current password. A text field the run filled with a stored secret is masked like a password, and the check for a password change counted it as one, so a sign-in form with a username and one password field read as two password fields: the password field was taken for a new password and the run stopped at
needs_inputasking for anew_passwordsecret after filling only the username. A password field is now one the page declares (type=password); a masked text field is not one, for the new-password check, for a credential change at submit, and for which credential a field asks for. A sign-in page that marks its one password fieldautocomplete=new-password, as pages do to keep browsers from filling it, stopped the same way; only a form with more than one password field now sets a new password or counts as a password change, and the marker says which of its fields are new. - Jev knows how much of the page lies outside the viewport. Jev saw only the viewport's text, so on a long single-page list whose answer sat further down, its read assessment found nothing and it scrolled screen by screen until the run stalled, never reading the page. An observation now counts the characters of visible text outside the viewport (
offscreen_text), Jev's step and the recovery LLM are given that count, and Jev is told that a read takes in the whole page. - A site that fails for a moment is retried, and its failure is never the answer. A search page that showed "something went wrong" with a Reload button beside "No results returned" got the recovery advice to click Reload, but the next step re-picked the DONE that had just been refused and the run ended
stuck. Recovery's problem now carries into the next step on the same page. Jev is asked each step whether the page reports that the site failed, and is told the HTTP status, a navigation error the browser hit (such asnet::ERR_CONNECTION_RESET) and how many steps the failure has stood; the page's own address is offered to reload it. The completion check is told about a standing failure, and an empty result shown beside one is not an answer. When the limits run out on such a failure, the run endsunavailable, naming the failure and its address. - Jev is asked whether to read a value a later action needs. Jev's read assessment was asked only while an information requirement was unread, so a sign-in task whose only question was the account email visited the Phone page, saw the code, went back to the code boxes without it and returned for it until the run stalled. The question is now asked on every readable page and names values the remaining actions need, such as a code shown on another page, beside the evidence for unanswered requirements.
- A requirement's copy of a supplied value is checked against the task. The planner restates each action with the values the task supplied, and a restatement that miscopied one (a code of 587373 written as 373, or grace@example.com as user@example.com) made Jev judge a completed sign-in unmet. The planner is told to copy each supplied value exactly, and the completion check is told that where the requirement and the task differ, the task's words are what the user asked.
- A fallback stays with the step it corrects. Asked to order with the postcode NOTAPOSTCODE and to fix anything the site rejects, the planner could write the order with NOTAPOSTCODE as one requirement and the fix as another, so an order placed with a corrected postcode never met the first and the run ended
stuck. The planner is told that a fallback the task gives for a step stays in that step's requirement, which its supplied value or the fallback meets. - Every entry point takes one run shape. The CLI,
serve, the MCP server and the Python and Node bindings all build the sameRunTaskand hand it, with what the host supplies (keys, secrets, callbacks), to one run function, so a rule about the run's arguments lives in one place and refuses the same way everywhere. A refusal names the field it is about, assecrets[0]: missing field \origins`, in serde's words rather than imitated pydantic and Python exception text, and arguments that contradict each other (such asattachwithout a browser to attach to) are refused as invalid params before any browser starts.RunParamsnow carriescloud_extensions,cloud_timeout_minutes,allowed_origins,fetchandfetch_first. The CLI checks for model keys and Chrome before it starts, asserveand MCP do.fastbrowse.resolve_cdp_portis gone; passcdp_portand the run resolves it. The scripted stand-in runs build only with--features scripted`. - A browserless read decodes and parses a page as a browser does. The fetch reader now decodes by the WHATWG Encoding Standard, so any charset a browser reads is read (a
<meta>charset included) instead of only UTF-8, Latin-1, cp1252 and ASCII, and it tokenizes with html5ever instead of a copy of Python's HTML parser, so a CDATA section or a raw-text element reads as it does in Chrome. Text a stylesheet class rule hides is now read, since a cascade is the browser's to compute; an element's ownhiddenattribute or inlinedisplay: nonestill keeps it out. A body past 5 MiB, before or after decompression, still hands the page to the browser. - Code paths nothing reached are gone. The guessed-address hold that withheld quotes read on a page the run had guessed, the rank standings for counted groups, the collection-page record and the
omitted_controlsfield of an observation (the browser always reported 0) are removed, along with the Bitwarden and TOTP copies in the browser crate, theverifyLLM purpose, the MCP server's unused GET event stream (a GET now answers 405, as the MCP spec allows for a server with no stream) and a fixed npm package size in the bench report. The MCP server reports its own version inserverInfo, and a bench replay with a missing cassette fails instead of skipping the task. - The browser and the Jev client report facts and leave the verdict to Jev. A Jev choice whose chosen option was not the most probable one was refused as invalid; it now stands, and only the answer's structure and its probabilities summing to one are checked. A link is taken for the next page of a list only when the page marks it
rel="next"or it is a numbered link to the next page with the same filters; a label such as "Next" or "Show 20 more" no longer makes code page a list or keep the control past the relevance shortlist, so Jev picks a pager the page does not mark. A click on an option, checkbox or radio that left no value set was recorded as no progress whatever the page showed; what it changed is now stated in the history and the one stall rule judges it. A file an earlier step already downloaded is reported as downloaded again instead of as a click that changed nothing. The capture no longer adds a "Visible h1 headings: 0" line to a page without a heading, and the covered-control and refused-download notices state what happened without telling the run what to do next. - Jev's own answer decides whether a form value is given. Before a run stops at
needs_input, Jev is asked whether the task or notes already hold the missing value; the stop stood unless that answer clearedvalue_stated_above, a bar of ours set at even odds. The threshold is gone: the stop stands unless Jev says yes. - Jev's read answers stand. A count requirement was kept from Jev's short-fact read, so a total the page states went to the LLM reader every time; Jev now sees it with the rest and answers it, or sends it on as synthesis. Jev's "this page holds nothing" stood only on a page it saw whole, and a focused page was read by the LLM anyway; it now stands either way. One bar, 0.90, decides whether a chosen value, an absent answer or a "nothing new here" answer stands, where "nothing new" needed only 0.80. Which requirement a counted list read in full covers, when the plan has more than one, is Jev's answer rather than whether the requirement's words name the list's heading or page title. A counted record whose group label the reader set is kept even when the record's text does not repeat that label, and a claim whose excerpt occurs more than once in its cited blocks keeps the whole cited run as its quote, as a blank excerpt now does, instead of the claim being refused.
- Jev picks every fill of a form. When Jev picked one field of a form, code typed the form writer's values into the other empty fields itself, as steps credited to code, and a value for a field that declares an email address was refused unless it held an
@. Now the form writer still writes every empty field of the form in one call, and its values are kept: each later fill Jev picks in that form types its kept value without another writer call. The@check is gone, since the writer already sees the field's input type. The browser no longer checks after each fill whether the form stayed the same, soAction.form_fillandActResult.form_unchangedare gone. - One rule decides whether an action that may commit goes ahead. It proceeds when Jev judges it not irreversible, or when the run is authorized and Jev judges the task asked for it; otherwise the run stops at
needs_confirmation. An authorized pick at 0.90 or more no longer skips that question, soThresholds.sensitive_act_fromis gone, and an authorized dialog accept or caller-supplied address is asked whether the task requested it rather than refused. The question whether a caller's address is a page to visit is gone too, since picking it was already Jev's decision. A password change is told by the form, not by words in its labels: a submission of a form holding more than one password field is never taken on Jev's word in an unauthorized run, and thenew_passwordsecret goes into the second and later password fields of such a form. A password field whose role the page leaves unclear stops atneeds_inputinstead of being given the stored password. Jev's question whether the task asked for an action now counts a step the task lists in order, even one a later step corrects, and for a submission it says what the form's fields hold; a button carries theform_idof the form it submits. - The LLM's recovery advises Jev instead of overruling it, and error pages and walls are Jev's. Recovery's named action replaced a pick Jev was sure of whenever answer outputs were still open; it is now taken only when Jev is unsure again or escalates, and its subgoal reaches Jev either way. A recovery that gives up no longer ends the run: it counts as one more recovery, and its diagnosis (a missing input, an unverified answer, or a sign-in Jev agrees is a wall) becomes the status once
max_recoveriesis spent. A fill value recovery proposed was typed when a word match found it in the task; the field's value is now chosen as any other fill's is. An authorized commit Jev judges the task did not ask for stops atneeds_confirmationinstead of going round recovery until the run is stuck. An HTTP error page no longer goes straight to recovery: Jev is told the status in the step's page facts and goes back, picks another link or escalates, and the status still names the stop when recovery runs out. A sign-in wall Jev judges blocks the task stops the run at once; the read that tried to prove the page readable is gone, and Jev's wall question says a prompt to sign in before replying gates only writing when the page shows what the task asks for. The plan'sinspect_accessfield is gone, since the wall question already asks whether the task inspects access. - Jev's read assessment is the read decision, and one stall rule governs every step. Code forced reads before an interaction, after a redraw, before going back from an unread page and before a pending receipt was read; it vetoed a scroll over unread evidence, a link that had failed or gone stale, an action repeated from the same page and an idle action, and kept separate read budgets for barren pages. Those rules are gone, along with
StallRules.barren_reads. When Jev judges a page to hold evidence the notes lack, the step reads it unless Jev picked DONE or ESCALATE. Jev is told, in the step state'spage_facts, when the page changed after it was last read, when a list page has not been read and when a possible commit has not had its page read. A step that changes nothing, a read that adds nothing or repeats one already made, a refused DONE and a return to a page state already seen with nothing read since each count toward the one stall rule; three in a row ask Jev again without the stalled action. A page state not seen before or new evidence renews the recovery budget. - Jev decides when a run is done. Code finished a run on its own after paging a list, after a read that evidenced every requirement, or on a click of the next-page link once a lookup was answered, and it turned Jev's DONE into a read or a READ into DONE. Each of those is gone: after a read or a walk through a list the loop asks Jev again, and only Jev's DONE starts the completion check. That check now asks Jev about every requirement, information requirements included, with the cited notes in view, so a run never ends
completewithout a Jev call. An information requirement no note cites is stated to Jev in its question rather than refused by code, and the check is also told the page's HTTP status and whether the page changed after it was last read. A requirement Jev gives no answer for counts as not met. A refused DONE puts what is still unmet in the history the next step is decided from. The finish no longer stops a run because the page it ends on answered an HTTP error; a submission that landed on one still stops it. The publication and benchmark gates no longer count more Jev calls as a regression. - A count is shown with the records it counted. The notes a step, the reader and the completion check see showed a tally as "tally ... 14" and left out the records it named, so the check judging the count saw no page quote behind it and answered that the count was unmet. Those records are now shown beside the tally; only when the notes pass their budget is the tally line kept without them.
- An action counts as done once the run's record shows it. Jev's DONE option and its completion question asked whether each requirement was visibly satisfied, so a sign-in the run completed two pages earlier, or a file it downloaded without the page changing, was never judged met and the run kept repeating it. The completion question now names the page and the run's own record of what each action did as the evidence, and an earlier action's effect counts after its page is gone.
- Jev is told what the browser saw an action do. A click that downloaded a file, opened a tab or failed carried that detail in its result, but the history Jev decides from said only how the page changed, so a download read as "only the page text changed" and Jev clicked the link again. The detail now leads the action's effect, with the page change after it.
- A model's answer is read to its end however long it takes. Each LLM attempt was cut off 30 seconds after it was sent, so a long read or completion answer was dropped and retried from scratch, losing minutes a run or ending it
unavailable. The timeout now bounds silence instead: the wait for the response head and for each piece of the body after it, as an httpx timeout does. OpenRouter sends a keep-alive byte every few seconds while the model writes, so only a stalled provider times out. A retry's reason reads "silent for 30s". - A downloaded CSV file is read row by row. The file was one source block, so a reader citing the rows behind a total or count could not name them one by one and its answer was refused. Each row is now its own block under the header row, as a page table's rows are, and a file the server sent only part of says so in its heading.
- DeepSeek answers with reasoning off again unless asked. With reasoning on, a DeepSeek read could repeat the same lines of reasoning until the model's own 131,072-token maximum, spending five minutes and $0.16 on one call that returned no answer. Through OpenRouter and the gateway DeepSeek is sent reasoning effort
noneunlessFASTBROWSE_LLM_REASONINGsets one, as the provider docs state. - A reply cut off at the model's maximum is asked once more. A cut-off reply was reported at once and failed the run. The runaways measured were a provider's decoder writing whitespace inside the JSON, or one paragraph of reasoning repeated, until the model's 131,072-token maximum, and the same request asked again answered; the second cut-off is reported as before.
- The completion check takes Jev's more probable answer. A requirement counted as met unless Jev put its "not satisfied" answer above 0.70, a bar of ours, so a count Jev judged 69% likely unanswered, with one page of three unread, ended the run
complete. A requirement is now met only when Jev judges it more likely met than not, andThresholds.claim_problem_aboveis gone. - A tally that names its records is counted from them. When the reader named each counted record and also filled the field range meant to stand in for them, a field code could not resolve threw the named records away and asked the reader again, so a count across pages lost a page's records. The named records now count, and the field range is used only when no records are named.
- Jev's read runs every time Jev asks for it. Code skipped a read of content it had read before with the same requirements open and recorded the step as failed, so a run whose first read came back empty could never read the page again and ended
stuckchoosing READ and DONE in turn. A repeated read now goes to the reader like any other, and the stall rule still ends a run whose reads stop adding evidence. - The reader is told what a tally is for. The reader's response listed
talliesfirst with no description, and a reader asked for the total of three invoices or the item of the priciest order answered with an empty tally and no claims. The field now says it is only for a count of matching records, and that a sum, total of values or comparison is a claim. - A field for a whole name takes the whole name. The form writer was told to take the part of a stated name a field asks for, and it wrote "Ada" into a "Your name" field for a task signed Ada Lovelace. It is now told that a field for a name as a whole takes the name as stated, and only a field for one part, such as a first name, takes that part.
- A quote is found by its words when its block label is wrong. A claim whose excerpt was not in the block it named was dropped, so a reader that quoted "katherine@example.com: 423345" exactly but labelled it with the line above left the sign-in code out of the notes and the run stalled going back for it. An excerpt that is not in its named blocks is now looked for in the other blocks the reader was shown, and the claim cites the one block that holds it; a quote found in none, or in more than one, is still dropped.
- A tally names its records by the ids their notes show. A tally listed its records as
records(1,3,4,...), numbers for positions in the notes that no note line shows, so the completion check could not tell which quoted rows a count of 14 products across three pages rested on and judged it unanswered. Each counted record is now named by the id its own line carries. - The completion check is told what a tally note is. Asked whether a count was answered "only when a note quotes the page supporting it", Jev judged a count of 14 products, made by code from 14 quoted rows across three pages, unanswered, and the run ended
stuck. The question now says a tally note is a count code made of the records its basis names, supported by their quotes. - A count with no filter takes every record. Jev and the LLM record reader are asked whether each record on a later page passes every filter the requirement states. For "the total number of products listed" there is none, Jev answered about 0.7, and the LLM reader, given the record Jev was unsure of, returned no match, so a count of 14 products came out as 13. Both are now told that a requirement stating no filter counts or compares every record; replaying the recorded question moved Jev from 0.72-0.76 to 0.86-0.89.
- A line read twice keeps both claims. When a reader quoted one line first as context and then as the answer to a requirement, the notes kept only the second claim. A sign-in run read the Phone page line "katherine@example.com: 423345" as the code and then as the account email, lost the code, and went back to the Phone page for it until it stalled. The earlier claim now stays beside the new one.
- Jev sees what each note quotes. The notes in Jev's step state, and in the LLM recovery prompt, gave each note's claim without the page text it quotes. A reader called the Phone page line "katherine@example.com: 423345" a saved password, and Jev, on the code boxes with that claim alone, went back to the Phone page instead of typing the code. Every note now carries its quote, as the form writer's notes already did; replaying that step moved Jev from clicking the Phone link to filling the first box at 0.97.
- Jev's check that a covered control is plainly shown is framed for it. Jev's check that a covered control is plainly shown now tells Jev the page is untrusted and what a yes and a no mean, and a read whose instructions alone fill the LLM budget is sent as one prompt instead of one call per character.
- No output token ceiling. Recovery, the field writer, the reader and the composer used to send
max_tokensof 2,000 or 8,000, which could cut a reply off mid-JSON. They now send no cap, and the model's own maximum and the answer schema bound the reply. Theread_output_tokensandcompose_output_tokenssettings are gone,FASTBROWSE_LLM_EXTRA_BODYcannot setmax_tokensormax_completion_tokens, and a reply that still ends mid-JSON is reported as cut off instead of being retried. The plan, the verdict and the shortcut address no longer send 8,000, 400 and 200 either. A Messages API request sends 128,000, the documented maximum of the current Claude models, since that API requires one. A PythonLLMClient.generateno longer takesmax_output_tokens. Through OpenRouter and the gateway, Gemini 3.8 Flash is sentlowand DeepSeeknoneunlessFASTBROWSE_LLM_REASONINGsets an effort; any other model, Claude included, is sent none and keeps its provider's default. The verifier reads the notes and the page whole, and every requirement the plan lists is checked, navigation included. A requested order total is the one the order summary shows before the order is placed. The MCPbrowsetool takes a task, field descriptions and a field list of any length, a browserless read keeps any page with readable text and--fetch-firsttakes a bot check Jev sees in it to the browser, a style rule inside@media printno longer hides text, and a blocked result quotes the whole wall. - Gemini 3.8 Flash is the LLM for every purpose. Field text and the shortcut address run on
google/gemini-3.8-flashtoo, instead ofgoogle/gemini-3.5-flash-lite, so a run has one model's failure modes to explain. DeepSeek V4.1 Flash was tried as the default and completed 86 of 95 live fixture runs, where Gemini 3.8 Flash at low reasoning completed 110 of 111 on the same code. DeepSeek stays supported throughFASTBROWSE_LLM_MODEL. - A result names the commit that produced it.
--jsonresults carry abuildobject with the package version, the git commit and whether the tree had uncommitted changes, andfastbrowse.models.CliResultvalidates that output as aRunResultwith itsbuild. The--tracefile opens with the same record.fastbrowse --versionfrom a checkout readsfastbrowse 0.9.0 (e1d478b, dirty), so a working tree no longer passes for a release. The eval harness records the same three values from the same place. - A run that stops early keeps its own status under a spend limit. A run that stopped at its first step, such as one paused at
needs_confirmationbefore an irreversible click, cancelled the plan request still in flight. OpenRouter bills a non-streamed request whether or not it is read, so the cancelled plan became an unknown cost, and a capped run reportedbudget_exceededwith "spend limit cannot be enforced" in place of the status it stopped with. A startup call already sent is now waited for and its receipt recorded; one not yet sent is still cancelled. - A spend limit holds through the Vercel AI Gateway. A gateway call that reported no cost, and whose receipt never settled, now counts as its model's context window at the dearest listed price, as an OpenRouter call already did, so a capped run goes on instead of stopping because the limit could not be enforced.
- A value a later action needs is kept when Jev answers the read. A sign-in that sends the run to another page for its code read that page, found nothing there for the question it was asked, and kept no quote of the code, so the run went back for it until it stopped. Jev now also says whether the page shows a value the task's actions need, and only a page it says yes to goes to the LLM reader for that quote.
- Jev sees the page only when the text leaves it unsure. Each step sent Jev the viewport screenshot beside the page text. Jev now decides from the text, and a pick under
recover_belowis asked once more with the screenshot before it goes to LLM recovery, so a step Jev is sure of costs no image and an unsure one gets a second look first. - An authorized run takes the commit its task asks for. Told to place an order, Jev agreed at 0.85 that the task asked for "Place order" and the run still refused it, since that agreement had to reach
sensitive_act_from(0.90). Over 22 labelled tasks Jev put every commit a task asked for at 0.66 or more and every one it did not, including commits the task forbade or only led up to, at 0.08 or less. The agreement now counts above the newrequested_abovethreshold (0.50), and the question is asked as one positive question: "Does the task ask the agent to do this?" - Jev, not the LLM reader, decides whether a count or comparison needs every page of a list. Code paged a list and had Jev match its later pages only when the LLM reader wrote
through_end: true. Gemini wrote it for a whole-site count and DeepSeek did not, so on DeepSeek the LLM read every later page itself: a count of one author's quotes took 390 seconds and 52,000 output tokens, against 18 seconds on Gemini, and missed three of the ten. The reader no longer has that field; Jev answers it per requirement with the task in view, and code pages the list from a yes at 0.70. - A click on a covered control uses where Jev saw it even when Jev gives that spot no confidence. TypeSafe documents a Box answer's confidence as null when the model gives none, and its own example answer is null, but the client refused a null, so Jev's located box was dropped and the click fell back to the hit test. A missing confidence now leaves the decision to Jev's answer that the control is shown.
- A conclusion the reader cites from the page stands, and one completion check decides when a run is done. Layers that overrode the reader are gone: the next-page notice that made it hold back an answer, the forced re-reading of earlier pages, the second LLM confirmation of a stated sort order, the records-only re-read after a conclusion, and the strip of a cited winner or total on a list still marked as continuing. A cited conclusion now settles its requirement even when an earlier page left it open. The finish keeps Jev's check that every information requirement is evidenced and every action requirement is visibly met, and drops the holistic done question, the LLM verifier with its doubt and guessed-address checks, and the per-claim answer check with its composer correction loop. Irreversible-action confirmation, secret redaction and authorization are unchanged.
- A page is read in one prompt, and nothing a read or check is shown is cut to a picked length. The LLM reader saw a page in 12,000 or 24,000-character chunks, so a list or a fact split across a chunk boundary was read in pieces; it now sees the whole page when it fits the LLM input budget beside its instructions, and a larger page is split into the fewest even chunks. Jev is offered a passage of any length to quote rather than only those under 320 characters, a rank claim's check shows every counted group with its full label instead of the leading three and two either side, a quote cut from a record of any length keeps the whole record beside it as context, and a contradiction check shows every other quote from the cited pages that Jev's input limit holds rather than the first 4,000 characters. A reader may write an excerpt past 2,000 characters, a field label past 200, a comparison of more than 60 results and any number of claims, and an answer correction reaches the composer whole. A read reference or composed claim citing evidence it was never shown is now recorded in the trace when it is dropped. A failed run's
erroris no longer cut to 500 characters. - Jev presses a control the hit test calls covered. On TypeSafe's own API and OpenRouter a refused click is put to Jev with the viewport screenshot: a yes or no on whether the control is shown with nothing drawn over it, and a box around it. When both reach the target bar the click lands at the box's centre; otherwise it stays refused as before.
- Jev sees the page it is choosing on. On TypeSafe's own API and OpenRouter each step's action decision is sent the viewport screenshot in TypeSafe's image format with its images header, named
viewport_screenshotin the step's state. The gateway, and any backup after a failover, are asked the rest of the state without the image or its reference. No screenshot is sent while a secret shows on the page. - Jev counts a list's later pages, the last included. The LLM reads a filtered count's first page and cites its matching records; on every later page Jev matches each record of the same shape against the requirement and code counts them, ending the list where no next page is shown, so the last page needs no LLM read. Only the records Jev is unsure of go to the LLM, on their own rather than with the whole page, and a long list is no longer cut at 60 records. A read claim that names no requirement no longer marks every requirement as lost.
- An irreversible action is taken unasked only when Jev is sure the task names it. An authorized run skips the confirmation for a commit only when Jev answers at 0.90 or more that the task asks for that exact action, as before; a lukewarm yes no longer waves a purchase or deletion through. Jev's check that a covered control is plainly shown now tells Jev the page is untrusted and what a yes and a no mean, and a read whose instructions alone fill the LLM budget is sent as one prompt instead of one call per character.
- Jev decides the clicks, walls and receipts that word lists used to. A click labelled Play, Pause, Resume or Mute was let through without asking Jev whether it commits, so "Submit resume" or "Pause payments" could skip the confirmation an unauthorized run needs; Jev's irreversible question now decides every click. A page Jev judges a sign-in wall now stops the run, or is read first when it may still answer, instead of being passed over when its controls matched no sign-in word, and a run recovery gives up on as signed out ends
needs_loginonly when Jev agrees the page is a wall. An authorized checkout no longer reads the page after every "Add to cart": Jev is asked whether the step committed anything before its receipt is read, and a step that commits nothing owes no read. An empty-state sentence such as "Be the first to post a comment" is left to the reader rather than matched against an English phrase list. - Jev sees a long page whole. Direct TypeSafe now asks Jev with its long-context header, and it, OpenRouter and AIMLAPI fit a Jev request to the 262k tokens they document instead of 32k a question, so a dense page's text and controls are no longer shortened or dropped to fit 32k. The gateway keeps Jev's default limits, and an LLM prompt keeps its budget.
- Jev answers a stall before the LLM is asked. When a run stalls or Jev is unsure, Jev is asked again with what failed in its state and the action that changed nothing left out of its options; a confident pick is taken, and the LLM recovers only when Jev stays unsure. Repeating an action that changed nothing, a commit included, now goes to recovery instead of being retried. Recovery no longer rewrites a give-up into DONE or a DONE into a read, no longer hides links that failed earlier, and no longer navigates to a guessed section before asking. An authorized run whose task names the commit takes Jev's pick without a recovery, and a refused finish names the requirements the verifier did not confirm instead of "completion not confirmed".
- Jev reads first on a task that also acts. A date picker, sign-in or checkout read was always the LLM's; Jev now answers what it can quote, field values included, and the LLM reads the rest.
- A step code chose is credited to code.
decided_bytakescodefor a step a rule in fastbrowse chose rather than a model: turning to the next page of a list and reading it, the fields after the first in a batch the form writer filled, DONE once a lookup is answered, and the reads owed before an interaction, after a page changed or before a sign-in prompt is called a wall. These steps were credited to the LLM or to Jev, so a count run's trace showed "click by llm on Next" for paging no model asked for, and per-decider stats overstated how much of a run the LLM decided. A code step carries no confidence, a recording captions it "picked by code", and the Python, TypeScript, Go, Java and .NET types list the new value. - Jev 1.14 on every route. OpenRouter asks
jev-1.14, direct TypeSafejev-1.14.0, the AI Gatewaytypesafe-ai/jev-1.14.0and AIMLAPItypesafe/jev-1.14, each pinned so a new release is measured before a run asks it. - A long run's finish check fits Jev's documented limit, and a model is told every bound its reply is held to. The done check sent every action and the whole page, which on a long run could pass Jev's 32k token input limit; it now drops the oldest actions first and says how many, cuts the page text only when that is not enough, and refuses a state that still does not fit rather than send it. A strict schema keeps
maxItems, which validation enforces. The verifier gets the screenshot on a page with no text, not on any page under 40 characters. - The eval judge reads every form post a run sent, and a replay miss shows its whole diff. The judge saw only the last post to each path, so a claim about an earlier submission could not hold; it now gets each path's posts in order. A replay miss keeps the full diff and every Jev question id instead of cutting them at 200 lines and 120 characters, an evidence row with no task, suite or arm is refused instead of exported as
unknown, and tokens a second counts only the LLM calls that were timed. - DeepSeek V4.1 Flash 1017 is the default LLM for every purpose. Planning, reading, recovery, the verdict, field text and the shortcut address all run on
deepseek/deepseek-v4.1-flash-1017instead ofgoogle/gemini-3.8-flashandgoogle/gemini-3.5-flash-lite. - The page scripts hand over what the page shows, whole, and a form's refusal reaches Jev as page facts. A captured page no longer cuts labels, names, image addresses, records or form text at fixed lengths, stops counting controls, images or links at a quota, skips drawings under 48px or guesses star ratings from class names; a downloaded text file is read whole instead of its first 16 KiB, with no 64 KiB eviction of older files; and a click that a covering frame intercepts names every control of that frame rather than eight. A field now carries
requiredandinvalidexactly as the page marks them, in place of the derivedblockingflag and its rule, and an action that changed only the page text, such as Sauce Demo's checkout showing "Error: First Name is required", now says so instead of "nothing visible changed". A download the browser could not hand over is recorded as refused, with its reason, instead of disappearing. - Jev sees the whole page, history and notes, fitted only to its documented limit. A step no longer cuts the viewport text, the working notes, the action history or the visited addresses at fixed sizes, the browser no longer drops controls past a pool of 320, and an effect names every control it showed or removed in full. A request is fitted to Jev's documented 32k and 64k tokens at 1.5 characters a token: past that, it loses its oldest actions first, keeping any value set, then has its recovery memory, page text and notes cut, each cut saying how much it left out. The relevance filter now runs when a page has more controls than a group step can offer or its request does not fit, rather than past 160 controls, and a step the gateway sheds is retried once without its off-screen controls rather than halved again. The
max_controls,max_offscreen_controls,max_offered_controls,viewport_text_chars,working_notes_chars,history_entries,earlier_history_entriesandmax_choice_optionsobservation settings are gone, and the token budget defaults rise from 24k and 48k to Jev's 32k and 64k. - A page read is told which lists continue from earlier pages and is asked for the value itself. On a comparison or count across pages, the reader of a later page saw only the requirement ids, and often neither carried the list on nor concluded it, so the run fell back to recovery. Each read now names the requirements an earlier page said run on, with how many records are collected so far, and says each must be continued or concluded. A read claim must also state the requested value in its text: reads cited the right blocks while saying only where the answer was.
- One model setting and one reasoning setting.
FASTBROWSE_LLM_MODELandFASTBROWSE_LLM_REASONINGnow apply to every LLM purpose; the per-purposeFASTBROWSE_LLM_MODEL_<PURPOSE>andFASTBROWSE_LLM_REASONING_<PURPOSE>settings are gone, since every purpose runs on one model by default. The formerFASTBROWSE_JEV_SOURCE,FASTBROWSE_JEV_BASE_URLandFASTBROWSE_JEV_MODELnames are no longer read; use theirFASTBROWSE_DECISION_names. - DeepSeek V4.1 Flash 1017 is the default LLM for every purpose, with reasoning off. Planning, reading, recovery, the verdict, field text and the shortcut address all run on
deepseek/deepseek-v4.1-flash-1017instead ofgoogle/gemini-3.8-flashandgoogle/gemini-3.5-flash-lite, and OpenRouter and the gateway are sentreasoning: {"effort": "none"}unlessFASTBROWSE_LLM_REASONINGorFASTBROWSE_LLM_REASONING_<PURPOSE>asks for an effort. The model reasons at every effort and does not scale it to the output allowance, so a short call could spend its whole cap thinking. Any other model is sent no effort and keeps its provider's default, since some, such as Gemini 3, refusenone.FASTBROWSE_LLM_PROVIDER=anthropickeepslow, as before. - A read claim keeps its citation on every provider that serves DeepSeek. On OpenRouter, 12 of the 21 DeepSeek V4.1 Flash endpoints tried answered
nullfor every optional object in a structured reply while optional strings came through, so each read claim arrived uncited and was rejected, and a checkout that showed its total stopped as stuck. For DeepSeek, an optional object now goes out as one nullable field per leaf, such ascite__firstandcite__last, and is folded back before the reply is checked. It is also senttemperature: 0: at its default, one plan in four from Together listed only some of the task's requirements or repeated"true"to the output cap.FASTBROWSE_LLM_EXTRA_BODYcan still set a temperature. On Sauce Demo, two of three checkouts completed in 20 to 23 seconds, where none had. - A refused OpenRouter key moves the LLM and Jev to the gateway key beside it. A revoked
OPENROUTER_API_KEYended every run at its first call withLLM HTTP 401: User not found., even with a workingAI_GATEWAY_API_KEYset. The run now continues on the gateway, and with no gateway key the error names the host that refused the key. A run that fails keeps its error: a model call cut short by the failure used to report it asbudget_exceeded,a call reported no cost. - A sign-in's first fill no longer waits for the plan. Writing a field waited for the whole planner call, so the browser sat idle after Jev had already chosen to fill the username: 33s on a planner that timed out once. A field is now written from the task alone until the plan arrives.
The release notes stop here. Every change is in CHANGELOG.md.