mrkeyoor.comAsk

Sac-Y/Jev-cutested 11 Nov 2026commit 52d32ac

Jev-cu review

Choose Jev-cu for supervised experiments with readable controls inside an existing Codex Computer Use workflow.

  • Safety failed
  • Tests pass
5 sto install
  • 0 packages
Automationevaluationupdated 19 Nov 2026
+1stars / 7d

Jev-cu is a Codex computer-use skill that sends interface-text candidates to Jev for action selection. Codex Computer Use reads the interface and executes actions. Its Chinese operating guide covers macOS App Accessibility output.

Verdict

Choose Jev-cu for supervised experiments with readable controls inside an existing Codex Computer Use workflow. Our installation took 5 seconds and the test command took 4 seconds at 52d32ac. Skip it for unattended consequential actions or visual-layout work. Inspect candidates, policy inputs and resulting state separately.

Jev-cu infographic: chooses actions from readable interface controls, plus our test result and who it suits
Tested 11 November 2026: the source install took 5 s.

We ran it

Lab card: what happened when we ran Jev-cu
Lab card from our sandbox run
Screenshot of Jev-cu (github.com/Sac-Y/Jev-cu)
github.com/Sac-Y/Jev-cu
Install✓ · 5s0 packages · 1 MB
Buildn/ano build script
Tests✓ · 4sran, no count parsed
Known vulns00 critical · 0 high · 0 moderate · 0 low (npm audit)
Repo19 files~1,179 lines of source · 0.1 MB · 0 CI workflows · tests dir

Answers from our run

Does Jev-cu build from source?

Dependencies installed in 5 seconds (0 packages), and the project has no separate build step. We cloned commit 52d32ac into a clean Debian container with 3 CPUs and no project-specific setup.

Do Jev-cu's tests pass?

Yes. The project's own test command exited successfully in 4 seconds, although its output did not expose an individual test count.

Does Jev-cu have known vulnerabilities in its dependencies?

npm audit found none in the dependency tree at the time of our run.

Who should not use Jev-cu?

Users seeking unattended consequential actions.

What are the alternatives to Jev-cu?

typesafe-computer-use, jev-codex-cua. Choose Jev-cu for supervised experiments with readable controls inside an existing Codex Computer Use workflow.

Setup4/5Our source checkout installed in 5 s with 0 dependencies, but we did not run a README task.Editor’s note: Repository installation succeeded; a complete evaluation of the supported Codex desktop setup is outside these package checks.
Docs4/5The README has an install section (“安装 skill”) and a usage section (“使用”); we did not run its quickstart ourselves, and the README is mostly in Chinese, not English.Editor’s note: Chinese guides document setup and operating rules, but the evidence does not support a numerical documentation-coverage assessment.
Community1/5Last push on 2026-09-22, 633 stars and maintainers answered or closed 2 of the 7 most-discussed issues we sampled.Editor’s note: Author posts and issue reports document experimentation without measurements of sustained support capacity or response quality.
Maturity1/5No tagged GitHub release, repository created 2026-09-18 and its test suite passed in our sandbox.Editor’s note: The supplied corrective commits implement these changes; their inclusion in our measured checkout is unverified. Repeated desktop-task reliability has no measured result here.

How we score

Who it’s for

Existing Codex desktop users evaluating supervised choices among readable interface controls.
Developers inspecting observations, candidates, policy decisions and results separately.
Operators able to follow Chinese setup and recovery instructions.

Who it’s NOT for

Users seeking unattended consequential actions.
Workflows centered on canvas layout, 3D modeling or visual-quality judgments.
Users seeking a standalone desktop application rather than a skill inside Codex.

Setup reality

Our November 11, 2026 sandbox run at commit 52d32ac installed Jev-cu in 5 seconds and completed its test command in 4 seconds. It recorded 0 dependencies and 1 MB on disk. Build was skipped because no build script or target existed. npm audit reported 0 known vulnerabilities. The configured sandbox had 3 CPUs, 8 GB RAM and image label lab-node:22.

The README places the execution loop inside Codex desktop's cua_repl runtime and requires a TypeSafe API key. Installation copies the skill to ~/.codex/skills/jev-cu, with a new session required. The operating guide recommends inspecting a dry-run before execution.

The November 13 attempt failed the lab's Compose-file prerequisite. Its run summary nevertheless described deployment, and teardown recorded ok. The body retains both records and explains their conflict.

Short answer

Jev-cu installed in 5 seconds and completed its test command in 4 seconds in our sandbox at commit 52d32ac. Choose it for supervised experiments inside an existing Codex Computer Use session, where the next action involves choosing among readable controls. Skip it for unattended consequential actions or work centered on visual layout. Jev chooses from interface text, while Codex prepares the task, handles exceptions and checks the resulting state, according to the Jev-cu operating guide.

The Jev-cu README describes an installable skill rather than a standalone desktop application. Jev selects an element, action, completion judgment and risk judgment from text candidates; Codex Computer Use reads the interface and executes. This division gives an evaluator separate components to inspect. An empty candidate list concerns observation and filtering, a blocked action concerns policy, and a completed task requires evidence from the application's resulting state. Those outcomes should remain separate in a review trace.

What people use Jev-cu for

Sac-Y reports using Jev-cu to operate apps inside Codex, particularly tasks requiring frequent judgments and tool calls. The author's X account, posting as Saccc_c, describes more noticeable acceleration on that kind of work. The report identifies a practical starting audience: someone already using Codex to operate an app who wants to examine a separate chooser's decisions among visible controls. It describes the author's experience rather than supplying a numerical task benchmark.

MrJev's issue #6 report describes element-selection checks and a sensitive Calendar deletion scenario while preparing a review. The reporter says 18 unit tests passed and all 12 P0 cases selected the correct element. In the deletion scenario, risk=0.91 and the sensitive-word gate both stopped the click. The same report describes a separate offline long-label reproduction that received a proceed verdict, giving readers two distinct policy outcomes to examine.

The operating guide recommends small goals with observable success conditions and records of results, elapsed time, Jev decisions and host takeovers. A harmless navigation task in an allowed app follows that structure. Retaining the original observation, selected candidate, policy outcome and resulting screen state makes the trace useful: candidate selection shows what the chooser picked, while the next observation shows what the application did. Codex actions belong in their own count, as the guide's stopping and takeover instructions specify.

What happened when we ran it

Our November 11, 2026 run at commit 52d32ac completed installation in 5 seconds and the test command in 4 seconds. These are our measurements, recorded by the sandbox harness. The configured environment had 3 CPUs, 8 GB RAM and image label lab-node:22. The checkout scan recorded 19 files, about 1,179 source lines and 0.1 MB checked out. The table preserves the skipped build alongside the successful package commands.

Source-check step Our result Meaning
npm install Succeeded in 5 seconds The recorded installation command completed
Dependencies 0 recorded, 1 MB on disk The harness recorded the local dependency footprint
Build Skipped, no build script or target The harness found no build target to run
Tests Succeeded in 4 seconds The recorded test command completed successfully
npm audit 0 known vulnerabilities across all reported severity categories The package advisory scan returned zero known vulnerabilities
Source scan 19 files, about 1,179 source lines, 0.1 MB checked out The recorded checkout size
Packaging scan 0 CI workflow files, no Dockerfile, tests directory present The detected repository automation files

The November 13 attempt failed the lab's Compose-file safety check. Its specific failure record says none of compose.yaml, compose.yml, docker-compose.yaml or docker-compose.yml existed, and the procedure required one. The run summary nevertheless describes deployment through the project's own Docker Compose configuration with every port bound to 127.0.0.1. Those records conflict. The operational outcome reported here is the failed prerequisite; teardown recorded ok.

The two procedures used different entry points. The November 11 harness ran repository package checks. The November 13 procedure required Compose, while the README places the execution loop inside Codex desktop's cua_repl runtime. That distinction explains where each procedure began and where the later one stopped. The documented desktop route starts by loading the installed skill in a new session and using the host's computer-use runtime, rather than starting a repository container.

Where people get stuck: inspect candidates first

Issue #5 reports empty Windows choices, while issue #4 reports 37 parsed Calculator elements producing zero candidates. Both reports locate a failure before useful Jev selection. Inspecting the observation, parsed roles and candidate list therefore comes before changing prompts or credentials. The public corrective commits address CRLF parsing, localized roles and full-label policy input at their own revisions, with each diff addressing a particular path described in the issue reports.

Reported problem Corrective commit or proposal Diagnostic action
Windows snapshots produce empty choices commit 04efcfab changes CRLF handling Inspect parsed elements and line endings
Chinese Calculator roles disappear from candidates commit e2cc92d adds localized-role normalization Compare observed roles with candidate indices
Long labels lose sensitive words commit e2cc92d restores the observed label before loop policy evaluation Inspect the original label at the policy boundary
A response hangs after headers Issue #12 requests timeout coverage through body parsing Inspect the complete provider-request lifetime
Repeated observations show no progress Issue #8 proposes bounded reobservation and deterministic exits Retain observations and stopping decisions together

The Windows reporter in GitHub issue #5 describes CRLF fixtures leaving carriage returns that prevent the parser's line match. Empty elements lead to empty target choices and HTTP 400: Choice question must have at least one choice: target. The report says the failed round used 0 tokens because rejection occurred before inference. The merged CRLF correction changes line splitting in both parsing and context construction.

The Calculator reporter in GitHub issue #4 identifies revision 38fb31de7dfe6209bbe6e04057c00c6e885ba577, package version 0.1.0. Chinese role descriptions survived parsing, but English-only filtering removed the buttons, so the loop returned escalate with zero actions before calling Jev. The localized-role correction maps the observed Chinese roles to internal role names while retaining localized display text. The correction changes adapter input handling rather than model-language capability.

Issue #12 reports a timeout gap before response-body parsing

Issue #12 reports that the request timer is cleared after response headers arrive and before response-body parsing finishes. Its local reproduction uses a stream that sends partial JSON and stays open. In that reproduction, timeoutMs fails to bound the full request, leaving the call pending. The report concerns response handling rather than a rejected request or an incorrect action choice, and requests timeout coverage through receiving and parsing the body.

A step budget counts loop iterations, while the request deadline described in issue #12 controls waiting within an iteration. In the reported failure, the iteration is still awaiting its decision response, so counting steps supplies no release from the pending body read. The useful diagnostic record identifies whether headers arrived, whether body parsing completed and when the timer was cleared. These details explain the reproduction without attributing it to candidate quality, confidence or API credentials.

Policy checks use the observed label in the corrective commit

commit e2cc92d uses the observed candidate label for action-policy checks instead of the shortened model label. The corrective commit shows that assignment before policy evaluation. It addresses the path described in GitHub issue #6: a sensitive suffix beyond the 120-character shortened label disappeared from keyword matching, and a supplied low-risk decision received proceed in the offline reproduction.

The same issue contains a separate stopped deletion scenario. With an explicit Delete Event label, the reported risk value of 0.91 and keyword check both blocked the click. Keeping the outcomes separate explains the deterministic correction: the deletion example exercised two matching safeguards, whereas the long-label reproduction exposed the effect of shortening policy input. The corrective diff includes regression-test code for long labels and misleading adapter labels, documenting the intended behavior of that changed path.

The README documents default dry-run behavior and an explicit app allowlist. The operating guide assigns the host responsibility for handling interface text as data and restricting transmitted content to the task. It also says URL cleaning and truncation are not privacy redaction. A trace that preserves the full observed label, shortened decision payload, local gate result and executed action exposes these separate stages of the authorization and execution path, using the guide's evidence-recording instructions.

Repeated observations need a stopping decision

Issue #8 reports that repeated unchanged observations are logged without ending the loop and proposes deterministic exits. Its routing proposal describes bounded execution, reobservation, reasoning handoff and visual handoff, with the caller owning planner callbacks. It links implementation PR #9 as ready for review. The proposal addresses a specific selection problem: a plausible choice among text candidates can still require reasoning or visual evidence from the host.

The operating guide tells the host to stop after two identical actions fail to produce the expected result. It also requires observed state to support completion and says Codex actions should be counted separately. Those instructions give a trace concrete fields: before-and-after observations, repeated action, stopping decision and takeover. A reviewer can then distinguish an application that stayed on the same screen from one where Codex made progress after taking over the task.

Chinese onboarding and localized controls are separate inputs

Jev-cu's README and operating guide are Chinese, while the README's example uses an English goal. Installation copies the skill to ~/.codex/skills/jev-cu and takes effect in a new session. The README installation instructions place the TypeSafe key in .env.local or the same-named environment variable. English-speaking operators need to understand the safety and recovery instructions alongside the setup commands, because those instructions determine when the host stops or takes over.

The operating guide covers macOS App Accessibility output and directs ordinary tasks toward a reliable CLI or API when one exists. Documentation language and interface-role handling affect different inputs: translating instructions helps configure the host, while role normalization determines which observed controls reach the chooser. Issue #4 illustrates the latter with Calculator, where the digit's button existed in the observation but disappeared during candidate filtering. Reading the observation and candidate list together locates that failure before model selection.

Jev-cu vs typesafe-computer-use and jev-codex-cua

Jev-cu runs inside Codex Computer Use, typesafe-computer-use documents its own screen-reading loop, and jev-codex-cua exposes desktop tools to Pi. Host and observation requirements give readers a concrete first comparison. The comparison article recommends Jev-cu for an existing Codex session and typesafe-computer-use for standalone Mac automation. Their primary repositories describe the architecture differences summarized below, which determine what each project expects the surrounding runtime to supply.

Project Observation and host Pick it when
Jev-cu Codex Computer Use reads and executes; Jev receives text candidates You already have the Codex desktop workflow and want supervised selection experiments
typesafe-computer-use Its own loop combines OCR, Accessibility controls and prepared state You want to evaluate a desktop pipeline outside an existing Codex session
jev-codex-cua Installed Codex/Sky runtime supplies desktop tools for Pi; native mode is default and Jev is optional Pi is your host and you want its documented runtime integration

The typesafe-computer-use README describes deterministic screen reading and a classifier that chooses the next action. Its primary repository explains OCR, Accessibility input and code-prepared facts such as dates and focused fields. Its published timing and cost figures describe that project's setup. Comparing the architecture identifies which observation and state-preparation work each system supplies before a reader considers a decision-service timing or cost comparison.

The jev-codex-cua README documents native mode without a TypeSafe key and optional Jev mode. Its primary repository describes Pi tools powered by an installed Codex/Sky runtime. Meanwhile, issue #11 asks whether Jev-cu users want general adaptation guidance or a maintained Pi-specific adapter. The thread requests a concrete host API and expected workflow, which are practical inputs for choosing between adaptation work and evaluating the separate package.

What the other reviews get wrong

Hermes's headline calls Jev-cu 200x faster and cheaper, while Jev-cu's operating guide says a general end-to-end multiplier has not been demonstrated. The Hermes article makes the broad claim; the comparison article reports no shared task-success benchmark. The author's account describes acceleration on decision-heavy work. Those are different statements, and our five-second installation and four-second test command measure neither application speed nor savings from delegating decisions.

Build with Jev's overview describes sensitive-action confirmation gates. Issue #6 adds two distinct outcomes: the explicit deletion scenario stopped, while the offline long-label reproduction received proceed. The public corrective commit then changes the label reaching loop policy evaluation. Reading the overview, issue report and corrective diff together gives readers the sequence needed to understand the correction without treating a general safeguard description as a complete account of its inputs.

Jev-curate is a separate dataset-filtering project appearing in the related search intent. Its repository material specifies a 0-to-4 reasoning-depth score and a keep threshold of 2.0, while the Jev Directory entry describes reasoning depth as 1-to-5. The research synthesis also identifies the directory's constructor-only Python description as inconsistent with documented filter_text and filter_file methods. These corrections concern dataset curation; neither API descriptions nor curation throughput measure Jev-cu desktop performance.

FAQ

Issue #11 requests a concrete host API and workflow before resolving Jev-cu adaptation to Pi or another agent application. That answers the host-integration question at the level recorded in the thread. The other questions below come from reported parsing, policy, routing and timeout problems. Their answers retain the distinction between an issue reproduction, a corrective diff and a host operating instruction, so readers can connect each symptom to the relevant stage.

Can I use Jev-cu in Pi or another agent application?

Issue #11 distinguishes general adaptation guidance from a maintained Pi-specific adapter and requests the caller's API and expected workflow. The included adapter expects getApp/getAXState and related actions, according to the host-integration discussion. The separate jev-codex-cua repository documents a Pi route using Codex/Sky, with native and optional Jev modes. Compare the host's observation and action methods with those interfaces before choosing an integration route.

Why do Jev-cu's Windows P0 tests return HTTP 400 with no target choices?

Issue #5 attributes empty choices to CRLF parsing that returned no elements. In the Windows reproduction, the service rejected the request before inference because the target question had no choices. commit 04efcfab changes parser and context line splitting to accept CRLF. Parsed elements and candidate counts identify this particular failure earlier than credentials or model output, because the malformed choice set already exists before the request is sent.

Why does Jev-cu find no candidates when Calculator exposes Chinese Accessibility roles?

Issue #4 reports 37 parsed elements and zero candidates because English-only filtering discarded localized roles. The Calculator report records an escalate result with zero actions before Jev was called. commit e2cc92d adds mappings for the observed Chinese roles and retains localized display text. Comparing observed roles with candidate indices locates the reported failure in the adapter's filtering stage rather than in a decision about the digit itself.

Can long Accessibility labels bypass Jev-cu's sensitive-action keyword gate?

Issue #6's offline reproduction received proceed after truncation removed a sensitive suffix beyond 120 characters. The long-label report separates that result from a deletion scenario stopped by both risk and keyword checks. commit e2cc92d changes the loop to use the selected observation's label before policy evaluation. The diagnostic distinction is which label the gate receives: the full observation or the shortened description used for the model-facing question.

Can Jev-cu hand off a step that needs visual interpretation or deeper reasoning?

Issue #8 proposes caller-owned reasoning and visual handoffs alongside bounded execution and reobservation. Its routing proposal links PR #9 as ready for review and describes opt-in routing rather than an extra mandatory service. The proposal gives the caller responsibility for deciding whether the next subtask fits the text-only action space or requires further evidence. A high-confidence selection alone supplies neither the missing visual information nor a planner's reasoning.

Does Jev-cu stop when repeated observations show no progress?

Issue #8 reports unchanged observations being logged without ending the loop and proposes deterministic exits. The no-progress report concerns loop behavior, while the operating guide separately instructs the host to stop after two identical ineffective actions. Reviewing both the loop outcome and host stopping decision preserves that difference. The before-and-after state, repeated action and takeover record show which component ended the attempt and whether the application changed.

Does timeoutMs cover reading the entire Jev response?

Issue #12 reports the timer being cleared after headers and before body parsing completes. Its response-body reproduction keeps a partial JSON stream open, leaving the request pending after the timer has been removed. The requested behavior covers headers and body receiving and parsing together. For that reproduction, a smaller configured timeout would leave the same uncovered stage once headers arrive and the timer is cleared.

What we have not tested yet

Our evidence covers repository checks at 52d32ac and a stopped Compose-based attempt rather than a completed Codex-native desktop task. We have not measured repeated task success, total wall time, total cost, host takeover rate or desktop memory use. The successful test command has no recorded passing-test count. The dependency footprint excludes external desktop prerequisites, the image label supplies no actual runtime versions, and npm audit covers known package advisories rather than desktop-agent safety. The November 13 attempt produced no completed task answers or screenshot records.

The supplied corrective commits implement these changes; their inclusion in our measured checkout is unverified. The CRLF, localized-role and full-label corrections have no new desktop retest here. Current-version applicability of the timeout and no-progress reports, merged availability of routing PR #9, broad localization coverage and other-host compatibility also lack a pinned reproduction or source confirmation. The separate jev-codex-cua README calls that project experimental and macOS only, and reports unreliable complex forms, browser controls and multi-step workflows.

Issue #14 recommends independent safeguards for consequential decisions and explicitly says its notice does not imply that this repository is necessarily exploitable. Its security notice supplies a warning rather than a demonstrated Jev-cu exploit. Prompt-injection resistance, safety across real applications, comparative whole-task savings and browser batch-judgment acceleration fall outside our results. A useful next evaluation is a harmless navigation task in an allowed app, beginning with dry-run inspection and retaining the observed result, every failure and each host takeover.

Alternatives

ProjectWhat it isPick it when
typesafe-computer-use gh↗A desktop loop using OCR, Accessibility controls and deterministic state preparation.Choose it for evaluation when you want a desktop pipeline outside an existing Codex Computer Use session.
jev-codex-cuaDesktop tools for Pi using an installed Codex/Sky runtime, with default native mode and optional Jev mode.Choose it when Pi is your host and you want its documented Codex/Sky integration.

Sources

  1. Full-label and Chinese-role correction
  2. Merged CRLF correction
  3. Jev-cu operating guide
  4. Jev-cu README
  5. typesafe-computer-use README
  6. jev-codex-cua README

More automation reviews