Skip to content

Ultrafast troubleshooting: what to do when it won't connect, clicks don't work, or it goes off track ​

When running Jev Ultrafast hits a problem, it's most likely stuck at one of four layers: the local service isn't up, Chrome isn't connected, the model call was rejected, or decision execution hit a wall. This lesson goes through common jev-ultrafast errors one by one by their original error text, giving the cause and fix for each—first do the 60-second quick check, then match your error to the list.

All original error texts come from the repository source code (jev_ultrafast/model.py, agent.py, browser.py, demo.py, and the inspector UI), searchable word for word and copyable for asking questions. It's fine if a prerequisite lesson has you stuck—whenever installation and running blows up at any step, you can come back here to look it up.

What you'll be able to do after this lesson ​

  • Use 4 commands to locate within 60 seconds which link is broken: the directory, the Key, Chrome, or the browser execution layer
  • Match jev-ultrafast errors to their fixes: original error text → cause → fix steps
  • Distinguish how three classes of errors are handled: stale ones (auto mode heals itself), retry ones (the code backs off automatically), and hands-on ones (you need to change the config or the target)
  • Understand the 6 displays of the inspector status bar, and know what to do next for done and blocked respectively
  • Remember the unsupported list: shadow DOM, frames, canvas, uploads, opening new tabs, nested scrolling, arbitrary keyboard components
  • Use Export trace to export decision evidence and ask questions with minimal information

Your current predicament ​

  • Start demo doesn't respond when clicked, and you don't know whether the service isn't up, Chrome isn't connected, or the Key isn't configured
  • The English error in the red box flashes by, and you don't know which phrase to search for—or even if you find it, you can't tell which layer is at fault
  • The agent status becomes done / blocked, but the page isn't the result you wanted—did you write the target wrong, or can this page simply not be run?

When to use this technique ​

When you need to:

And you don't want to:

  • Delete the repo and reinstall from scratch at the first error, walking through the whole installation process again
  • Fail to tell apart "the page changed, retry" from "the config is broken, fix it," and waste half a day making the wrong changes

🎒 Preparation before starting ​

  • completed Ultrafast installation and running (it's fine if you're stuck—this lesson is exactly for getting you unstuck)
  • the repository is cloned locally, and your terminal can run commands in the jev-ultrafast/ root directory
  • (optional) you've gone through writing your own browser tasks—errors you hit when using the Agent library can be matched here just the same

Core idea ​

Identify the layer first, then look at the error. An Ultrafast task has to pass through four layers, and each layer's errors look different:

LayerWhat to checkTypical error / symptom
1. Local serviceuv run jev whether it's running, whether the directory is right, whether the address is 127.0.0.1Cannot reach local demo server / Forbidden
2. Chrome connectionBrowser Harness, remote debugging authorizationthe panel stays motionless
3. Model callsthe two Keys, network, quotaTYPE_TEXT needs TEXT_MODEL_API_KEY / Model provider returned HTTP 401
4. Decision and executionpage changes, action budget, page widget boundariesTarget changed or is covered / status becomes blocked

Three classes of errors, three ways of handling them. Classify the error first when you see it—don't rush to act:

ClassExampleWhat you need to do
Self-healing (stale, the page changed)Page changed since the decision / Target changed or is coveredDo nothing: automatic runs will re-observe and decide again; in manual mode, click Choose next once
Retry class (server temporarily rejects)429 / 529 / 503 → the code attempts 3 times in total (2 retries), and if it still fails, reports Model provider returned HTTP 429/529/503Wait a bit and run again; check your quota
Hands-on class (configuration / budget / boundaries)Missing key, HTTP 401, 60 action budget, shadow DOM not supportedFollow the items below to change the configuration, change the target, or switch pages

💡 inspector status bar reference table (original text from app.js)

Status bar showsMeaningWhat you should do
Ready to exploreStart demo has not been clicked yetFill in the target and click Start demo
Page observed · ready for a decisionPage observed, waiting for a decisionClick Choose next or Run automatically
Choice ready · inspect or executeDecision made, pending executionCheck the probabilities, then click Execute choice
Jev reports complete · inspect the pageThe model chose DONEVerify the page yourself—DONE is not proof of success
Stopped · no supported next actionblocked: consecutive invalid actions or the model chose BLOCKEDLook at the last few steps in the Decision trail and compare against the unsupported list
Paused · needs attentionPaused due to an errorLook at the original error text in the red box and match it to the cases below

First troubleshooting pass: 60-second quick check ​

Run the four commands in order, verifying the directory, key, Chrome connection, and browser execution layer in turn. Prerequisites: the terminal running uv run jev is still printing Jev Ultrafast: http://127.0.0.1:8766, and the browser was opened with 127.0.0.1:8766 (not localhost; see the Forbidden troubleshooting entry below for the reason).

bash
# 1. 当前目录对吗?——.env 从「当前目录」读取,必须在仓库根目录跑
pwd
# 应以 jev-ultrafast 结尾;不在就先 cd jev-ultrafast

# 2. 两个 Key 都配了吗?——应看到两行(值非空才算数)
grep -E "^(TYPESAFE_API_KEY|TEXT_MODEL_API_KEY)=." .env
# 顺手 echo $TYPESAFE_API_KEY 确认 shell 里没有旧值抢先——.env 不会覆盖已 export 的变量

# 3. Chrome 连得上吗?——官方诊断命令
uv run browser-harness --doctor
# 按提示在 Chrome 里允许远程调试

# 4. 浏览器执行层正常吗?——官方开发命令,不调用模型、不花 API 费
uv run python scripts/check_guards.py
# 在本地浏览器里跑执行守卫回归;脚本自己的说明:No model calls or external websites

You should see: item 1 ends with jev-ultrafast; item 2 outputs two lines; item 3 completes the connection diagnostics; item 4 ends by printing PASS: N browser guard checks; no model calls. Fix whichever item breaks; if all four pass and there is still an error, the problem is almost certainly in the model call or decision layer—match it to the cases below.

Troubleshooting common problems ​

Startup and Chrome connection (cannot connect) ​

"Cannot reach local demo server" ​

Cause: the inspector page cannot connect to the local service—uv run jev is not running, the port was changed, or the page is an old tab. This message appears in the status bar (the fetch-failure branch of app.js).

Solution:

  1. Restart from the repository root; the terminal should print:
bash
uv run jev
# Jev Ultrafast: http://127.0.0.1:8766
  1. Open http://127.0.0.1:8766 in the browser. If you changed the port: TYPESAFE_DEMO_PORT must be set before startup (demo.py reads the fixed port at module import time); see the advanced tips in the installation and running lesson.

Opening the page only shows "Forbidden" ​

Cause: you used localhost:8766 instead of 127.0.0.1:8766. The demo service validates the Host header and only accepts 127.0.0.1:8766—this service listens only on the loopback address (demo.py calls itself a Loopback-only inspector), and POST requests also get {"error": "Local demo requests only"}.

Solution: change the address bar to http://127.0.0.1:8766 and refresh.

Chrome cannot connect and the panel never moves ​

Cause: Browser Harness requires Chrome to allow remote debugging; Chrome shows a prompt on the first connection, and if you miss it or decline, the connection fails. From the README: Allow remote debugging in Chrome when prompted.

Solution:

  1. Run the official diagnostic command from the repository root:
bash
uv run browser-harness --doctor
  1. When Chrome shows the "allow remote debugging" prompt again, click Allow.
  2. If the diagnostics pass but it still does not move: first run the uv run python scripts/check_guards.py above—it does not call the model, so it can verify the browser execution layer in isolation.

"A browser step is already running" ​

Cause: the previous step is still executing. The demo service uses a global lock to ensure only one browser step runs at a time; requests that hit the lock return 409 along with this message.

Solution: wait for the current step to finish; if you want to stop Run automatically while it is running, click Pause.

"Local demo failed; no automatic retry. Reset to recover." ​

Cause: the demo service wraps any exception not specially caught into this generic 500 fallback message. The most common trigger: TYPESAFE_API_KEY is not set at all—model.py reads os.environ["TYPESAFE_API_KEY"] directly, and a missing key raises a KeyError; the original message is not shown and it falls through to this fallback.

Solution:

  1. Check the two keys in .env (with a 60-second quick check on item 2).
  2. Reset as prompted: click Start demo to start over.
  3. If you use the Agent library, you will see the raw traceback directly (e.g. KeyError: 'TYPESAFE_API_KEY'); handle it by filling in whichever key is missing.

"Start a demo first" ​

Cause: you clicked Choose next / Execute choice / Run automatically in the inspector before Start demo—the demo service rejects these commands when no agent has been created yet.

Solution: first fill in the target and click Start demo, then use the control buttons.

"Enter 1–2,000 characters" ​

Cause: the target is empty or exceeds 2000 characters (the reset validation in demo.py).

Solution: keep the target within 1–2000 characters. Passing an empty target with the Agent library raises Supply a task (agent.py)—same meaning.

Keys and model calls (the high-error zone for TEXT_MODEL errors) ​

"TYPE_TEXT needs TEXT_MODEL_API_KEY; no text is hardcoded or guessed by the executor." ​

Cause: .env is missing TEXT_MODEL_API_KEY. This check only triggers when the action is TYPE_TEXT (model.py's field_text()), so the demo can start and the page can be observed, but it stops as soon as you "type into an input box"—the Flights demo has to generate city names, so there is no way around it.

Solution:

  1. Fill in your text model key in .env (for where to get it, see method A/B/C in step 3 of the installation and setup lesson).
  2. Note the loading rules: .env is read from the current directory, and it does not override same-named variables already exported in your shell—if you clearly filled it in but still get the error, run cd jev-ultrafast again and check echo $TEXT_MODEL_API_KEY.

"Model provider returned HTTP 401; no action executed." ​

Reason: The model endpoint returned an error status code, which is wrapped into this message template (the source is f"Model provider returned HTTP {response.status_code}; no action executed."). 401 = invalid Key. This message is shared by TypeSafe and the text model, so first determine which side it comes from:

When it's reportedWhich sideWhat to check
Reported at the very first decision stepTypeSafe (decision is called every cycle)TYPESAFE_API_KEY
Only reported at the typing stepThe text model (only used by TYPE_TEXT)Whether TEXT_MODEL_API_KEY and TEXT_MODEL_BASE_URL match

Solution:

  1. On the TypeSafe side: go back to the console Keys page and re-copy the key; you can verify it with curl (the getting-started troubleshooting has the full command).
  2. On the text model side: confirm the key belongs to the endpoint you configured (an OpenRouter key with a DeepSeek endpoint configured is 401).
  3. For the meaning of other status codes (400/413/415/422 etc.), see the status code table in the API quick reference—429/529/503 are not reported immediately; see "Model provider returned HTTP 429/529/503" below.

"Model connection failed; no action executed." ​

Cause: The HTTP client threw an exception at the network layer—things like failing to connect to the endpoint or DNS resolution failure; the request was never sent out (model.py raises this message after catching httpx.HTTPError).

Solution:

  1. Check whether your network can reach api.typesafe.ai and your TEXT_MODEL_BASE_URL.
  2. Check the endpoint spelling: with TEXT_MODEL_BASE_URL a common mistake is a missing or extra /v1 (example value https://openrouter.ai/api/v1, DeepSeek default https://api.deepseek.com/v1).

"Model provider returned HTTP 429/529/503; no action executed." (rate limiting and overload) ​

Cause: The model endpoint returned 429 (rate limited) / 529 (overloaded) / 503. These status codes are not reported immediately: the code makes 3 attempts in total (2 retries, with 0.5s and 1s intervals); only if the 3rd attempt still fails is the status code template above used, reporting Model provider returned HTTP 429; no action executed. (529, 503 use the same wording).

There is also a fallback message in the source code, "Model unavailable" (model.py L27), but under the current control flow it is unreachable—after 429/529/503 retries are exhausted, the status code template is used, so this message never appears in the UI; if you find it in the source code, map it to this entry.

Fix: Wait a bit and run again; if it happens frequently, check your quota—on the TypeSafe side, view it on the console rate-limits page; on the text model side, check your provider's billing page.

"Invalid TypeSafe response; no action executed." ​

Cause: The decision response failed local validation (the validate_choice() of model.py: the chosen option must be among the candidates, every option must have a probability, all values must be within 0–1, and the probabilities must sum to about 1). This is a "response violates the contract" guard, not a problem with your configuration.

Fix: First just rerun as-is (it can be sporadic); if it persists, export a trace (see "Still not working?") and take it to feedback.

"Text helper returned no valid field value; nothing typed." ​

Cause: The text model's output does not conform to the contract—it must be JSON containing only the single key text, with a value that is a non-empty string no longer than 2000 characters (the parsing rules of model.py). Two common triggers:

TriggerMechanism
The target is missing a required valueThe model instructions explicitly state: return {"text": null} when a value is missing and never invent personal information (the TEXT_VALUE in questions.py)—null fails to parse, nothing gets typed
The model misbehavesIt outputs a passage of commentary text instead of JSON—the official performance report mentions rejecting such models during probing

Solution:

  1. Write the values the task needs into the target (dates, city names, and the like—don't make the model guess).
  2. If it still fails, switch text models and keep TEXT_MODEL_REASONING=none (models with reasoning disabled improvise less).
  3. Typing the wrong value (rather than not typing) is handled the same way—the official probing also rejected models that swapped origin and destination, so test with a small task before switching models.

Execution interruption and budget (nothing responds to clicks) ​

"Target changed or is covered. Observe again." ​

Cause: The pre-execution safety recheck found that the target changed: it was overlaid, hidden, disabled, moved out of the viewport, or is no longer the node it was at observation time. This is the guard doing its job, not a bug—model output only ever references real elements that were observed, and the geometry is re-verified once more before execution.

Fix: Observe again and make a new decision. In automatic runs (without Slow motion), each step goes through a tick, and these stale errors are automatically swallowed and followed by a re-observation, so you never see them; in manual stepping or slow mode, it pauses and shows the original message—just click Choose next once to make a new decision.

"Page changed since the decision. Choose again." ​

Cause: The stale family—the page changed after the decision was made, invalidating the old decision. Variants in the same family: Page changed before text generation. Choose again. (the page changed before typing), Page changed since this decision. Observe again. (pre-execution recheck), Document changed during evaluation / Document is navigating (the page was changing during observation).

Fix: As above—observe again. Two details:

  1. The typed value is not generated for nothing: only when the text helper's input is completely unchanged will the retry reuse the previously generated value (see "Reuse an interrupted text request" in the README).
  2. Frequent occurrences mean the page has lots of animations/loading; wait a bit before running, or switch to a more stable page.

"Page did not settle" ​

Cause: The page never settled across 10 consecutive observations (20ms apart each)—animations keep running or it keeps loading.

Fix: Wait until the page quiets down before running; some heavyweight pages (constant scroll animations, persistent skeleton screens) may simply be unsuitable.

Cause: The execution result of the native <select> was not confirmed, or execution was interrupted (variant wording: Dropdown execution was interrupted; inspect before retrying.). The code chooses to stop conservatively here rather than blindly retry—retrying could cause duplicate selections.

Solution: Observe again (Choose next / rerun), letting the agent make a fresh decision based on the new page.

"Observe and choose before acting" ​

Cause: In manual mode, Execute choice was clicked without a decision, or the page fingerprint changed after the decision was made and the decision had already been consumed.

Solution: Click Choose next once to get a new decision, then Execute choice.

"Stopped at the 60-action demo budget" ​

Cause: The hard budget for a single run is used up: at most 60 executed actions (MAX_STEPS = 60). Decision calls have a separate limit of 120 (MAX_STEPS × 2); when reached, Reached the demo's model-call budget is reported.

Solution: If the task is too big, split it into smaller ones — the official example parameter in examples/run.py is literally named 'A narrow goal', so writing a narrow goal is the official recommendation. If it doesn't finish within the budget, it usually means the goal is too broad or the page is unsuitable (see the group below).

"This run has stopped. Start a fresh demo." ​

Cause: The state is already done or blocked, yet a new decision is still being requested — one run has ended.

Solution: Click Start demo to start a fresh run.

Status bar shows "Stopped · no supported next action" (blocked) ​

Cause: Two sources: the model actively chose BLOCKED (instruction definition: no supported action can advance the task), or for 3 consecutive executed actions (none of them WAIT) the page showed no change at all — the code determines it's stuck and automatically switches to blocked.

Solution:

  1. Look at the last 3 steps of the Decision trail: what was clicked and why the page didn't change.
  2. Check against the "unsupported list" group below — the most common root cause of blocked is a control on the page that can't be operated.
  3. Make the goal narrower and more specific, then restart the demo.

Wrong results and page boundaries (going off track) ​

Status bar shows "Jev reports complete · inspect the page", but the page isn't what you wanted ​

Cause: The model chose DONE, but DONE is never proof of success — the official Evidence and limits section puts it bluntly: even after DONE is chosen, the result still needs independent verification. The second half of the status bar message (inspect the page) is exactly a reminder for you to look yourself.

Solution:

  1. Add independent verification for important tasks. The official template is examples/flights.py's verify(): check the results page item by item for one-way trip, origin, destination, date, and visible results — don't trust the model's DONE; if verification fails, exit and report Final page did not satisfy the route/date checks.
  2. Write the stop condition clearly in the goal. The official Flights example goal ends with Stop when …; follow that phrasing.
  3. Goals of the "open a certain result" kind deserve extra attention: the model instructions explicitly state that "finding a matching link alone doesn't count as complete".

Controls don't respond when clicked / not in the element list at all (shadow DOM, canvas, upload…) ​

Cause: You've hit an MVP boundary. The DOM reader only recognizes common HTML and ARIA controls and doesn't implement the full accessible-name algorithm. Per the official Limits list, the following are all unsupported:

UnsupportedExamples
shadow roots / framesinternal controls rendered by component frameworks
canvasmap- and canvas-style interactions
file upload<input type="file">
pop-up new tabslinks that open a new tab when clicked
nested scrollinginner scrollable containers
arbitrary keyboard componentskeyboard shortcuts, rich-text editors

Solution: Before starting a task, screen it against the list first; for now, don't force your way through pages involving these controls (step 4 of the principles lesson has the same boundary list); switch to a page or task that only involves regular controls. Also note: the agent's tab shares your existing Chrome profile — your login state affects page content, so keep that in mind when troubleshooting "the page isn't what I expected".

Typed text is wrong, or text that should be typed wasn't ​

Cause: The string is inferred from the goal by the text helper, not written by Jev. Wrong text = the helper model misunderstood; no typing = it returned {"text": null} per the rules (refusing to invent values when the goal lacks required ones; see the nothing typed entry above).

Solution: Write required values verbatim into the goal ("September 20, 2026" instead of "next month"); if that still doesn't work, switch text models, probing first with a small task — the official process used six probe calls to eliminate models that swapped cities or output comments (see the performance analysis).

Fills the form but doesn't submit, types text but doesn't pick a suggestion ​

Cause: These rules are actually hard-coded in the model instructions: submit after filling required fields ("filled fields don't equal an applied search"), and after typing a query, select the matching autocomplete suggestion. Failures are usually a timing issue — after typing, the code waits at most 200ms for suggestions to appear, so sites with slow-loading suggestions may miss the next observation.

Solution: Rerunning as-is usually passes; if it keeps getting stuck at the same spot, make the goal more explicit (what to submit, where to stop), or switch to a page whose suggestions load faster.

Still not working? ​

Isolate first, then gather evidence, then ask with the evidence in hand.

The isolation tools are the two scripts bundled with the repo (both in scripts/, from the Development section of the README):

bash
# 只测浏览器执行层:本地页面、不调用模型、不花钱
uv run python scripts/check_guards.py

# 测完整链路:浏览器只开本地 fixture 页面,但会发起真实模型调用(产生付费 API 费用)
uv run python scripts/smoke.py

check_guards.py passed and smoke.py passed too, but the real website still fails — the problem is most likely with that site itself (control boundaries, load timing); check against the unsupported list.

Gather evidence — three things are enough:

EvidenceHow to get itWhat's inside
Decision tracethe Export trace ↓ button at the bottom of the inspectordownloads typesafe-browser-trace.json: full decision history, probabilities, goal, page URL and visible text (no screenshots)
What the model sawthe page's collapsible section What the model seesthe full request body sent to the model, inspectable field by field
The exact error textthe sentence in the red boxevery H4 on this page matches

⚠️ Review before sending

The trace contains the page URL and visible text, which may include your account information; also note: the live example and the recording script both make paid API calls (README's exact words), so be aware before reproducing repeatedly.

Where to ask:

ChannelWhen to go
This lesson + Install and runCheck yourself twice first; most problems never make it this far
Getting Started Troubleshooting / API Quick ReferenceTypeSafe API-side status code issues
GitHub IssuesDefects in Ultrafast itself: include the trace + the original error text + the goal and URL
TypeSafe DiscordIssues on the decision API (Jev) side; if the officials say it's broken, report it directly
Browser Use CloudIssues when using the hosted BU Ultrafast (model: "bu-ultrafast")

Checkpoint ✅ ​

  • 60-second quick check: all four commands have been run, so you know which layer is stuck
  • I can distinguish three classes of errors: stale self-heals, 429/529/503 auto-retries, and config/budget/limits need hands-on work
  • When the status is done I don't just call it a day—I add independent verification for important tasks (flights.py's verify() is the model)
  • I've reviewed the unsupported list: shadow DOM, frames, canvas, uploads, new tabs, nested scrolling, keyboard components
  • When asking questions I include typesafe-browser-trace.json, the original error text, and the goal and URL

Lesson summary ​

✅ Troubleshooting starts by identifying the layer: local service → Chrome connection → model calls → decision execution; each layer's errors look different.

✅ Every jev-ultrafast error message comes verbatim from the repo source and is searchable word for word; the H4 heading is the original error text—copy it to search or to ask.

✅ Three classes of treatment: stale errors go to automatic re-observation, 429/529/503 go to code retries, and only config/budget/limit errors require hands-on work from you.

✅ DONE is not proof of success, blocked means check the unsupported list first, and the 60-action limit is a hard budget—remember these three and half of the "gone off track" cases can be avoided in advance.

Quick reference of key signals:

SignalWhich layerFirst step
Cannot reach local demo server / ForbiddenLocal serviceRe-run uv run jev; open 127.0.0.1:8766
Panel stays frozenChrome connectionuv run browser-harness --doctor, allow remote debugging
TYPE_TEXT needs TEXT_MODEL_API_KEYModel calls (text side)Add the Key in .env, mind cwd and setdefault
Model provider returned HTTP 401Model calls (invalid Key)First figure out whether it's TypeSafe or the text model, then re-copy the Key
Model provider returned HTTP 429/529/503Model calls (rate limit/overload)Wait a bit and re-run, check your quota
Target changed or is coveredDecision execution (stale)Re-observe; auto mode self-heals
Stopped at the 60-action demo budgetDecision execution (budget)Write narrower goals, split tasks smaller
Status done but the result is wrongResult verificationVerify in person; add flights.py-style independent verification
Status blockedPage boundariesCheck against the unsupported list, switch pages or change the goal

Next lesson preview ​

That wraps up the browser chapters. The next lesson Jev 1.13 Pitfall handbook: 9 failure modes and alternative approaches returns to the Jev model itself—beyond Ultrafast, it applies to all Jev applications. You will learn:

  • The 9 failure modes in the official jaggedness docs: literal interpretation, arithmetic counting, date comparison, indirect reference…
  • Alternative approaches for each failure mode: put arithmetic in code, extract date components, filter large state first
  • How these questioning habits feed back into your Ultrafast goals and other Jev applications

Related tutorials ​

Appendix: source code reference ​

Click to expand and view the source code location

Updated: 2026-11-04 (repo github.com/browser-use/jev-ultrafast, local information source sources/jev/repo-ultrafast/)

FeatureFile pathKey location
Original error text: connection/HTTP/retryjev_ultrafast/model.pyL15–27 post_json(L20 connection failed, L21–23 automatic retry on 429/529/503·3 total attempts, L25 HTTP status code template, L27 Model unavailable fallback text·unreachable in the current control flow); L12 client timeout=25
Original error text: decision response validationjev_ultrafast/model.pyL30–45 validate_choice(L44 Invalid TypeSafe response)
Original error text: text helperjev_ultrafast/model.pyL160–198 field_text(L163 missing-key original text, L187–193 JSON contract validation, L193 nothing typed)
TypeSafe request and key readingjev_ultrafast/model.pyL119(api.typesafe.ai/v1/systemone + os.environ["TYPESAFE_API_KEY"], raises KeyError if missing)
Original error text: budget and state machinejev_ultrafast/agent.pyL74 stopped, L75–76 model call budget(MAX_STEPS×2=120), L88–89 observe before executing, L96/L107–108 stale original text, L102–104 60 action budget, L153–158 3 consecutive times with no change→blocked
Original error text: stale and execution guardsjev_ultrafast/browser.pyL86 Page did not settle, L102 page changed before execution, L130–131/L162–163 dropdown unconfirmed/interrupted, L164 target covered; L16 StalePage(ValueError)
Original error text: demo servicejev_ultrafast/demo.pyL16 port(set TYPESAFE_DEMO_PORT before startup), L23–29 .env reading(cwd + setdefault), L48–52 scenarios and 1–2000 characters, L64–65 Start a demo first, L111–112 409 single-step lock, L122–123 500 fallback
inspector status bar and error displayjev_ultrafast/static/app.jsL63 Paused · needs attention, L82–88 five status texts, L173–183 automatic loop(tick self-healing vs slow stepping), L217–235 export trace(screenshots removed), L243 Cannot reach local demo server
UI buttons and collapsible sectionsjev_ultrafast/static/index.htmlL56–59 Choose next / Execute choice / Run automatically / Pause, L126 Export trace ↓, L133 What the model sees
Model instructions(DONE/BLOCKED/submit/suggestion rules)jev_ultrafast/questions.pyL3–14 NEXT_ACTION, L21–24 TEXT_VALUE(returns null for missing values, does not invent personal information), L26 MAX_STEPS = 60
Installation, --doctor, remote debugging, unsupported-features listREADME.mdL53–68 Try it(includes uv run browser-harness --doctor), L118–126 Evidence and limits(DONE requires independent verification; shadow roots/frames/canvas/upload/new tab/nested scrolling/keyboard components unsupported; tabs share the existing Chrome profile), L128–138 Development(check_guards, paid API notice)
Unsupported-features list(Limits original text)docs/performance.mdL53–55; L49 probing rejected models(swapping origin and destination/outputting annotations)
Independent verification templateexamples/flights.pyL18–38 verify() item-by-item checks, L63–64 Final page did not satisfy the route/date checks
Local guard regression scriptscripts/check_guards.pyL1 docstring(No model calls or external websites), L133 final print PASS: N browser guard checks; no model calls
Local fixture smoke scriptscripts/smoke.pyL1 docstring(paid API), L19 --max-actions(default 15), L25 prints the trace directory
gaodong.aiAboutPrivacyContact

Independent tutorials, not affiliated with any product mentioned. Product names and trademarks belong to their owners. Check official pages for prices and policies.