NanoJev-Web

Open-weight browser hands for a larger planning agent. NanoJev-Web is a lightweight browser-action model derived from NanoJev. It runs locally and selects the next action from a host-provided set of permitted browser operations. The included agent-browser runtime executes the selected action and checks the resulting page state.

Use it as an execution component for form filling and bounded web workflows. A larger model or your application supplies the goal, named targets or selectors, values and success conditions; NanoJev-Web handles action selection within that contract. The weights, inference code and browser runtime are available for local integration. No hosted model service or API key is required.

Runtime 1.1 defaults to hybrid execution. Named workflows, animation settling and bounded retries are implemented in the executor. This release includes the same verified browser-head-v5 weights; it is not a new training run.

How it fits into an agent

Planning agent / application
    supplies a short workflow or explicit controls, values and success conditions
        ↓
Host observer → abstract page state + available action candidates
        ↓
NanoJev-Web → selected action ID + candidate probabilities
        ↓
Browser executor → performs the action → observes the new page state
        ↺
Host verifies the outcome or handles a blocked workflow

The model scores supplied alternatives without generating text. Selectors and literal form values stay with the supplied executor; it sends abstract action descriptions and page-state flags to the model. Planning and independent outcome verification belong to the host. Runtime 1.1 can resolve exact field/button names and execute staged workflows without precomputed CSS selectors. Integration guide and API.

Inheritance and browser specialization

NanoJev-Web inherits its decision architecture and tokenizer from C-Tianyu/NanoJev, using the Qwen3-0.6B backbone. All 596,049,920 backbone parameters remain frozen. The 200,578-parameter decision head was further trained on synthetic browser action states.

The released weights are the verified browser-head-v5 checkpoint. Packaging it as NanoJev-Web did not introduce another training run. Game interfaces, game datasets, game training commands and teacher-service integrations are excluded. Removing those components does not erase knowledge from the inherited weights. Training details · Provenance.

Property	Value
Total parameters	596,250,498
Output	One supplied action ID and probabilities over the alternatives
Storage	Full FP32 safetensors checkpoint; no quantization or adapter
Checkpoint size	2,385,039,280 bytes
Candidate context limit	768 tokens per separately encoded candidate path; overflows rejected
Local inference	PyTorch MPS on Apple Silicon; explicit CPU option
Tested hardware	MacBook Pro, Apple M2 Pro, 16 GB unified memory

Available browser actions

The supplied executor supports:

• Inputs: fill, type, clear, select, multiselect, check, uncheck, radio, upload.
• Interactions: click, hover, dblclick, drag, focus, press.
• Structured controls and navigation: open, option, add, remove, link, tab.
• Visibility: observer-generated scroll to reveal an allowed target.
• Control decisions: DONE, WAIT, BLOCKED.

These are executor capabilities exposed as permitted choices. The model does not invent commands. Same-origin frame targeting is available through a control's frame property. See the complete action reference for required data, semantics and boundaries.

Download

Download the complete repository with the Hugging Face CLI:

hf download candypunk/NanoJev-Web --local-dir NanoJev-Web

This includes the model files, configuration and local runtime. The root config.json describes the custom decision model and its file layout. Hugging Face uses this standard file for repository download statistics. Downloading only model/best.safetensors omits the rest of the runnable package and does not follow this counting path. See Hugging Face's counting rules.

Run locally

The supplied installer targets native Apple Silicon, macOS 14+, Node.js 24+ with npm, and uv. It installs pinned Python 3.12.13 dependencies and agent-browser 0.37.1. Installation downloads dependencies; model inference then uses local files. Other Apple Silicon generations have not all been benchmarked.

Tested on MacBook Pro with Apple M2 Pro and 16 GB unified memory. Successful operation was reported in a separate functional test. Hardware specifications and test scope.

cd NanoJev-Web
chmod +x *.command
./setup.command
./start.command

The model listens on 127.0.0.1:8774. In another terminal:

curl http://127.0.0.1:8774/api/health
curl -H 'Content-Type: application/json' \
  --data-binary @examples/choice-request.json \
  http://127.0.0.1:8774/api/evaluate

For a short named workflow, adapt examples/browser-workflow.json. The existing explicit control task is also supported. Run either format with:

./run.command --task your-task.json

The runner creates an isolated agent-browser session and returns one compact JSON result, with the full local trace and screenshot in .local/runs/. Use --session NAME --attach to delegate into an existing owned session. The default hybrid mode executes assigned native inputs deterministically while NanoJev-Web selects clicks, scrolling and other decisions. Use --mode model to route every action choice through NanoJev-Web. The examples require your own page; they do not include a demo website. Named workflows, animation handling and two bounded BLOCKED retries. For a Python-only model setup or your own executor, see integration.

This is a custom decision checkpoint. Load it with the supplied inference code; the repository root is not a standard AutoModelForCausalLM chat checkpoint or a configured Hugging Face Inference widget.

Evaluation and limits

On held-out synthetic decision states, the browser head selected an acceptable action in 228/228 cases. Development scored 191/192 and calibration 189/192. These splits share the training schema; they measure action selection within that schema, not success on arbitrary websites. Probabilities have not been certified as calibrated confidence. Data and methodology.

The current model and runtime target bounded workflows with supplied controls. They do not independently discover a site's workflow, invent form values, interpret arbitrary screenshots, manage credentials or make business decisions. The host must define success and verify any required saved data; a DONE choice alone does not establish business correctness. Changing the observation/action schema can change model behavior and requires evaluation.

Browser demonstration

The following recording illustrates the model in use. In one 15-field form attempt, NanoJev-Web completed and saved all assigned values in 19.85 seconds, using 20 browser actions and 21 decisions on Apple M3 Max / 36 GB. Jev and GPT-6 Astra High ran alongside it through the same browser executor for context.

Recording excerpt, seed 43129 (26.51 seconds of GIF playback). The clip ends with Astra showing “Booking saved” while its final decision is still pending. Final verified outcomes and elapsed times come from the saved run logs and result screenshot; GIF playback duration is not execution time.

This is one observed demonstration with supplied selectors and values, not a general browser reliability claim. It records the original runtime; the separate runtime 1.1 validation covers named workflows and recovery. The detailed recording report retains the comparison, timing, token accounting and verification evidence. The comparison application and its cloud-provider integrations are separate from this model distribution; only static documentation assets are included.

Release contents and privacy

The distribution contains the checkpoint, tokenizer, inference API, agent-browser executor, integration examples, synthetic browser-head data, model checks, documentation and license notices. The model's inherited MIT and Apache-2.0 terms are described in LICENSE.

Private machine paths, credentials, browser profiles and raw local run files are excluded. The safetensors header has no author metadata, and head training used abstract synthetic states. This audit does not establish that inherited pretrained weights contain no personal information. Privacy audit · Publishing instructions.