An agent completing a single action inside a piece of software is no longer the hard part. Demonstrations have been convincing for a while. The questions that actually matter sit on either side of that demo: did the agent do it correctly, and can a different agent repeat the same task from the same starting state?
Rhea 6.9.0, published on November 12, 2026 and verified on the main branch on November 19, addresses both. The release moves the tool from desktop product analysis into general desktop task environments, and adds a task composer, a task recorder and an independent verification path. It also brings Linux and Docker support and allows new clients to connect over MCP.
What Changed Between 6.8 and 6.9
The 2026-11-07 pre-release introduced state and permission rules for desktop tasks. That same version opened a standalone build. Over six iterations through 6.9.0, three capabilities consolidated:
- Task construction from an existing desktop state. The environment is captured as it is, not rebuilt from a script.
- One-click generation of multiple tasks from a single recorded flow. One trace yields a task family rather than a single test case.
- A verification stage that runs outside the agent’s own claims. The environment is inspected after the task ends, not the transcript.
The official Gnole description of the basic flow is worth quoting in substance. The initial state is a shopping list. The task is to add an entry — grapes — to that list. The environment contains no built-in answer to the exercise, only the concrete operation sequence. That distinction matters: the task is specified by the state and the expected end state, not by a narration of steps.
Four Stages: From Desktop State to Acceptable Task
| Stage | What happens | What it produces |
|---|---|---|
| 01 State recording | Capture the application’s initial state and record the demonstration | A replayable starting point |
| 02 Checkpoint selection | Confirm the stack and the end condition, save the replayable state | Seed and check points |
| 03 Task definition | Define one task with multiple requirements, set permissions per task | A scoped task with an explicit permission envelope |
| 04 Independent verification | Re-run in the same environment, compare the result against the expectation | A pass/fail judgment with recorded evidence |
The flow also settles a question that comes up in every evaluation discussion. Recording scope, application source and verifier design determine what the task actually covers. A single successful demonstration does not prove that every possible path in every piece of software has been covered. It proves that one path in one environment produced one verified outcome.
Verification pulls several things into one place: the coordinate inputs, the application window, the role state, the exported environment, and the checker that runs at the end of the task. Rather than handing a reviewer a video and asking for a judgment, the workflow produces a package where the initial data, the task description and the verification rules travel together.
Prerequisites Before Trying a Desktop Build
Two conditions apply, and they are separate. Being able to reach Rhea locally does not mean the machine has desktop-component capability.
The 6.9.0 release notes specify:
- Linux arm64 or an arm64 host.
- Node.js, per the supported version list below.
- Docker reachable without sudo.
- Around 20 GB of free space for Docker image storage.
- AgentEnv linked at 0.9.1485.
With those in place, the official example runs:
rea setup --client claude-code --desktop-build --install-agentenv --dry-run
rea desktop --client claude-codeThe first command prints a configuration plan without executing it. If uv is already present, --install-agentenv installs the specified AgentEnv version; if not, the plan shows the install step. The command does not bundle Docker or Node.js. After configuration, restart the client before running the second command — otherwise the desktop components are registered but not active.
A First Task: Validate the Path Before Trusting the Result
The official example warns against testing only two things: whether it runs, and whether the demo looks good. A task can look convincing and still be unverified.
A compact prompt that exercises the whole path has four parts. Drop any one and the result is not meaningful:
Build a Google desktop task environment with Rhea.
Application: an image clipping tool that accepts text input, including an image modeling tool.
Permissions requested: input can be operated, output can be read, network accessible.
Expected result: input.txt written successfully, click finish; clipboard outputs 1.5 lines of content, confirm saved.The four parts are the test premise, the application and the permissions it needs, the result to be verified, and the initial state that must be reproducible from a defined region. Permissions are not decoration here. A task that requests broader access than it needs produces a passing result that tells you nothing about whether the agent respected scope.
The permission envelope is the second thing this release fixes. Each task carries its own permission set — input operable, output readable, network reachable — and the verifier checks outcomes inside that envelope. An agent that succeeds by doing something outside its permissions has not passed; it has failed in a way that looks like success.
False Positives and the Value of a Hard Check
The inverted test is more informative than the direct one. Add a rule that a product must not pass the credit-card check, and see whether the environment rejects the attempt. A verifier loose enough to accept that action is a verifier that will also accept an agent claiming “the system test succeeded” without evidence.
That is the diagnostic purpose of a deliberately failing task: it exposes an over-permissive checkpoint. A task suite where everything passes is not evidence of a good agent. It is evidence of weak acceptance criteria.
A related caution appears in the release notes. A single laptop-shaped task does not mean the task has been accepted. An export without a business-level task check does not prove the parameters can migrate, and may not even be replayable. The presence of a task container is not the presence of a verified task.
Offline Analysis and Evidence Traceability
6.9.0 extends the previously public offline analysis of video evidence. The release notes list single-file runs, standalone runs, demo and complete modes, and add execution-adjacent values — value domains and read timing — into more of the graphical and file-system checks.
A concrete example is V8 code caching. The protocol can save the original source text and the saved bytecode before execution. Inspecting temporary captures, resource captures or pairings does not equal having collected complete source code, and the report needs to say which of those it holds.
Evidence handling changed in one more respect: score evaluation, selection calibration and malformed results are now folded into the report package or the scope check automatically. Where the boundary of the intermediate process is explicit, sufficient evidence can be retained. Where it is not, the gap has to be stated rather than smoothed over.
The consequence is about confidence, not presentation. A report must distinguish “checked and found nothing” from “this area was not covered”. Writing the unknown as certain is the failure mode this stage exists to prevent.
Updating Existing Installations
The correct update path depends on how Rhea was installed.
npm installs. Run:
rea updateThe command updates the global CLI entry and the package version bound to the npm browser path. It does not restart running clients for you.
npx installs. Re-run:
npx rhea@latest setupDesktop or packaged installs. Follow the installer’s own update flow. A docker run --dry-run does not start anything, so a dry run is not an update.
One rule holds across all three: after the package changes, restart the client. The setup step binds the execution entry’s install location at configuration time. A new latest tag on npm does not mean the old launcher is pointing at it.
A second rule concerns plugin users. If a client-side installer reports that components are missing, reinstall the component rather than reinstalling an identical service from scratch. Duplicate services cause more confusion than the original missing component.
Two Channels, Checked Separately
Release status needs to be verified channel by channel:
| Channel | Status | Note |
|---|---|---|
npm latest | 6.9.0, published 2026-11-12 | The installable release |
main branch | Commits dated 11-19 | Development progress; not the same as a published package |
| Client integration | Runtime → registration / plugin → restart | Re-confirm against the actual combination in use |
Reading a commit date on main as a release date is a common error. The verification pass on November 19 confirmed the published package behavior; it did not republish the package.
Runtime Alignment
Node.js support follows a specific list: 22.x from 22.23.4, 24.x from 24.22.1, and 26.12.1 and above. Versions 23 and 25 are not supported, and Node does not automatically promote a development build. A mismatch here produces failures that look like task-environment bugs and are not.
What the Release Actually Changes
The shift in framing is the substantive part. Earlier versions demonstrated that an agent could complete a desktop operation. 6.9.0 makes that operation reproducible and independently acceptable: a recorded state, a defined checkpoint, a scoped permission set, and a verifier that runs outside the agent’s narrative.
For developers, the practical entry point is a small task with a clear starting state and a checkable result. Start with one requirement, one permission envelope, one verifier. Confirm the whole path end to end before expanding to a task family. The failure modes that appear at scale — over-permissive checkpoints, unreplayable exports, evidence that covers the transcript but not the environment — are all visible in miniature on the first task if you look for them.
One infrastructure note applies to teams running these evaluations across several model backends. Task suites that mix providers accumulate credentials, quotas and rate-limit behavior that differ per call, and verification logs become hard to reconcile across them. Keeping model access behind a single gateway keeps the routing policy in one place and lets the task results stay comparable. TreeRouter provides consolidated access for teams running multi-provider agent evaluations, so a model swap does not change the verification pipeline.
The framing that survives the release notes: a demonstration shows what an agent did once. A task environment shows what any agent can be held to. The second is what makes evaluation mean anything.






