---
title: "System 1 Models in Owl Browser: Architecture Guide"
description: "Generative LLMs produce tool calls out of whole cloth, but System 1 models evaluate closed sets of choices."
canonical: https://owlbrowser.net/blog/driving-owl-browser-with-system-1-models/
---
# Driving Owl Browser with System 1 Models: Constrained Decisions, Local Bindings, and Zero Key Leakage

**In short:** Generative LLMs produce tool calls out of whole cloth, but System 1 models evaluate closed sets of choices. Owl Browser 1.4.0 introduces the /sys1 surface, pairing full page actions with typed evaluator questions, keeping values on-box, and upgrading our SDKs to 2.2.0.

By [Akram Hasan Sharkar](https://owlbrowser.net/team/#akram-hasan-sharkar), Founder & CTO Published September 25, 2026 Updated November 17, 2026 6 min read

![Real browser_observe output for the Hacker News front page: OwlMark rows with handle tokens next to the handle table](https://owlbrowser.net/blog/agent-render-handles.webp)

In Owl Browser 1.4.0 we added support for a second kind of model. Generative LLMs call tools through structured schemas; System 1 models are constrained evaluators that pick one option from a closed set. Pairing an OwlMark page render with such an evaluator keeps every decision small and bounded.

Owl Browser 1.4.0 introduces /sys1, a dedicated API surface that bridges the gap. It translates the active page into a closed set of complete, executable candidate actions described in plain English, and binds each option to a server-side tool call. When your evaluator picks a key, Owl executes the underlying action. The release also ships browser core support for Chrome 153 and 154, and upgrades our Python and TypeScript SDKs to version 2.2.0.

## Why Evaluators Need a Different Surface

When an agent powered by a generative model drives a browser, it inspects an accessibility tree or OwlMark render and invents a tool invocation. An evaluator model cannot invent anything. It requires a bounded decision space: given the current goal and page state, which of the following concrete choices is correct?

Converting a modern DOM into an executable choice set requires strict constraints:

- Every candidate must be an actionable, complete call. An option cannot be an abstract intent like 'type username'; it must pair a specific DOM element with a specific value ready for execution.
- Interactive elements generate clicks: links, buttons, checkboxes, tabs, and menu items each receive an absolute candidate key.
- Form fields require supplied values: if you do not pass a value definition to the observation call, the page produces clicks only. Owl will not guess what to type into a blank input.
- Unenumerable controls yield nothing: continuous inputs like free-form sliders or drag handles cannot be turned into a safe closed set, so Owl omits them rather than guessing.
- The none option is always present: every candidate set ends with a fallback choice. Without it, an evaluator model is forced to choose the least harmful bad option when a page is broken, stuck, or already finished.

## The Four-Stage Loop

On the /sys1 surface the browser never contacts a model provider. It prepares the request, you send it to the provider of your choice with your own credentials, and you hand the answer back. No provider API key reaches the browser.

The interaction pattern splits into four explicit steps: observe, ask, answer, and execute. Only the final step applies side effects to the browser page.

In the examples, `$OWL` is your instance's origin, for example `http://127.0.0.1:8080` for the HTTP server or the Docker origin; both route `/sys1/`.

bash

```bash
# 1. Observe: generate the state and candidate questions
curl -X POST "$OWL/sys1/observe" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
        "context_id": "ctx_0001",
        "goal": "Fill in the email address field",
        "values": [
          {
            "id": "email",
            "text": "ada@example.com",
            "description": "the account email address"
          }
        ]
      }'
```

The response provides a snapshot identifier, candidate definitions, and a ready-to-forward request payload tailored for evaluator models:

json

```json
{
  "state": {
    "goal": "Fill in the email address field",
    "page": {
      "url": "https://example.com/signup",
      "title": "Create Account",
      "view": "<compact page render>"
    },
    "suppliedValues": [
      {
        "id": "email",
        "description": "the account email address"
      }
    ]
  },
  "questions": {
    "action": {
      "type": "choice",
      "instructions": "Which single listed action best advances state.goal?",
      "criteria": {
        "c0": "Click link \"Terms of Service\"",
        "c2": "Fill textField \"Email Address *\" with supplied value \"email\": the account email address",
        "c7": "Scroll to the bottom of the page",
        "none": "No listed action is suitable, more information is needed, or the goal is already achieved"
      }
    },
    "goal_visible": {
      "type": "noul",
      "instructions": "Does state.page visibly demonstrate that state.goal is ALREADY achieved?"
    }
  }
}
```

## Zero-Leakage Credential Isolation

Notice what appears in state.suppliedValues above: only the identifier email and its description the account email address. The actual text ada@example.com is retained entirely within the browser host snapshot memory.

When sending requests to an external model provider, sensitive data such as passwords, personal identifiers, and session tokens are never sent to the model provider. The model selects candidate key c2, and Owl injects the corresponding value locally when executing the action.

## Separating Decisions From Execution

After querying your model provider, you post the response back to /sys1/answer. This endpoint is strictly inert: it validates the selection against the snapshot criteria and classifies the status, but does not interact with the page.

bash

```bash
# 2. Answer: validate and score without executing
curl -X POST "$OWL/sys1/answer" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
        "snapshotId": "s1_98a7df8b",
        "answers": {
          "action": {
            "type": "choice",
            "choice": "c2",
            "confidence": 0.93,
            "probabilities": { "c2": 0.93, "none": 0.07 }
          },
          "goal_visible": {
            "type": "noul",
            "noul": 0.05
          }
        }
      }'
```

The reply indicates whether the candidate passed validation checks:

json

```json
{
  "status": "proposed",
  "candidateId": "c2",
  "confidence": 0.93,
  "goalProbability": 0.05,
  "executed": false
}
```

Because /sys1/answer does not execute the action, you can inspect status before committing changes. If the model is uncertain, you can fall back to a human operator or abort the run:

| Status | Description |
| --- | --- |
| proposed | Actionable candidate above min_confidence (default 0.8) |
| needs_review | Candidate selected, but confidence falls below threshold |
| no_action | Model selected the none escape option |
| goal_reported | Goal completion probe indicates the task is finished |
| expired | The snapshot aged out past its 120-second validity window |

When ready to apply the step, call /sys1/execute with the snapshot and candidate identifier:

bash

```bash
# 3. Execute: trigger the side effect
curl -X POST "$OWL/sys1/execute" \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"snapshotId":"s1_98a7df8b","candidateId":"c2"}'
```

Snapshots are single-use. The server-side binding is consumed upon execution, preventing duplicate submissions or replayed network calls from firing twice.

## Handling Large Pages with Candidate Windows

When a complex web application contains hundreds of interactive elements, the candidate list can exceed single-call context budgets. Owl enforces candidate limits locally (up to 254 candidates plus the mandatory none option, roughly 60 KB total payload) so oversized pages fail fast at the browser rather than generating costly provider errors.

The observation call returns a coverage object indicating whether the page was windowed:

json

```json
{
  "coverage": {
    "totalCandidates": 412,
    "candidateOffset": 0,
    "returned": 100,
    "nextCandidateOffset": 100
  }
}
```

Candidate keys are absolute across windows (c0, c1, up through c411), ensuring a key never refers to two different actions when walking pages. Calls can target specific page segments using candidate_offset, max_candidates, region (such as main, nav, form, or dialog), and detail='min'.

## SDK 2.2.0: Python and TypeScript

Both official SDKs have been updated to version 2.2.0 with native support for the /sys1 workflow. The sys1.step() helper handles observation, provider invocation, confidence evaluation, and execution in a single call while keeping provider credentials in your code.

In Python:

python

```python
import os
from owl_browser import OwlBrowser, RemoteConfig, Sys1Value

config = RemoteConfig(url=os.environ["OWL_URL"], token=os.environ["OWL_HTTP_TOKEN"])
# add api_prefix="" when OWL_URL is the HTTP server itself (port 8080), not the Docker origin

async with OwlBrowser(config) as browser:
    ctx = await browser.create_context(render_mode="agent")
    await browser.navigate(context_id=ctx, url="https://example.com/signup", wait_until="load")

    step = await browser.sys1.step(
        ctx,
        goal="Fill in the email address field",
        values=[
            Sys1Value(
                id="email",
                text="ada@example.com",
                description="the account email address",
            )
        ],
        ask=call_model_provider,  # your function: sends the request to your provider
    )

    print(step.decision.status, step.execution.description if step.execution else "not executed")
```

Excerpt: runs inside an async function; call_model_provider is your own code.

In TypeScript:

ts

```ts
import { OwlBrowser } from '@olib-ai/owl-browser-sdk';

const browser = new OwlBrowser({
  url: process.env.OWL_URL,
  token: process.env.OWL_HTTP_TOKEN,
  // apiPrefix: '',  // when OWL_URL is the HTTP server itself (port 8080)
});
const ctx = await browser.createContext({ render_mode: 'agent' });
await browser.navigate({ context_id: ctx, url: 'https://example.com/signup', wait_until: 'load' });

const step = await browser.sys1.step(ctx, {
  goal: 'Fill in the email address field',
  values: [
    {
      id: 'email',
      text: 'ada@example.com',
      description: 'the account email address',
    },
  ],
  ask: async (request) => callModelProvider(request),  // your code
});

console.log(step.decision.status, step.execution?.description);
```

Excerpt: callModelProvider is your own code. Node SDK methods take the server's snake_case parameter names.

Setting auto_execute=False in Python or autoExecute: false in TypeScript pauses after decision resolution, returning the proposed step for verification before any mutation occurs.

## Chrome 153 and 154 Core Updates

Alongside the System 1 surface, version 1.4.0 updates our browser engine with support for Chrome 153 and 154. The profile roster, Client Hints generator, and anti-detect fingerprinting tables have been refreshed to match the latest stable browser builds. Context pinning now spans Chrome versions 143 through 154, ensuring your automation runs match modern browser signatures on the web.

## Availability

Owl Browser 1.4.0 is available today. Instances expose the System 1 reference documentation at GET /sys1/docs, generated directly from active engine limits. Python and Node packages are published on PyPI and npm as version 2.2.0.

Update (Nov 2026)

The current SDK release is 2.3.0 (`@olib-ai/owl-browser-sdk` on npm, `owl-browser` on PyPI). Owl Browser 1.4.2 runs on Chromium 156, and fingerprint profiles cover Chrome 143 to 156. The /sys1 limits quoted above are unchanged in 1.4.2 (254 candidates plus none, a 60,000-byte request cap, 120-second snapshots, min_confidence 0.8).

![Portrait of Akram Hasan Sharkar](https://owlbrowser.net/team/akram.webp)

About the author

[Akram Hasan Sharkar](https://owlbrowser.net/team/#akram-hasan-sharkar), Founder & CTO at Olib AI

Previously Lead Software Developer at Aloha, with over 14 years of systems engineering experience. Akram founded Olib AI and architects Owl Browser's custom C++ Chromium and Blink engine, source-level fingerprint virtualization, Agent Rendering (OwlMark), and MCP automation stack.

[Profile on the team page](https://owlbrowser.net/team/#akram-hasan-sharkar) [Akram Hasan Sharkar on LinkedIn](https://www.linkedin.com/in/ahstanin/)

## Try it on your own workload

Read the [API reference](https://owlbrowser.net/docs/), compare the [Node](https://owlbrowser.net/node-sdk/) and [Python](https://owlbrowser.net/python-sdk/) SDKs, or check the published [detection and token benchmarks](https://owlbrowser.net/benchmark/).

[See plans and the $0.99 trial](https://owlbrowser.net/pricing/) [All articles](https://owlbrowser.net/blog/)

## More from the blog

- [September 25, 2026 Browser NLA: Moving the Agent Loop Inside the Browser](https://owlbrowser.net/blog/browser-nla-in-process-natural-language-automation/)
- [August 6, 2026 MCP 2 in Owl Browser: Stateless Protocol, Composite Tools, and Telling the Truth About What Is Missing](https://owlbrowser.net/blog/mcp-2-in-owl-browser/)
- [July 27, 2026 Design a Flow, Skip the Script: Visual Browser Automation Without Code](https://owlbrowser.net/blog/design-a-flow-skip-the-script/)
