Clearcote Jet

Tell it what you want done on a website. Jet reads the page, picks the next step in about a quarter of a second, does it with a real mouse and keyboard in Clearcote, and hands you the answer.

Three live runs, recorded in real time; the captions are added afterwards from each run's log. Every step shows what Jet did, how sure it was, and how long it took to decide. Watch the MP4.

Why use it

• Fast. Each decision took 235 to 473 ms in our runs. Most of a run is the browser, not the thinking.

• Cheap. A finished task averaged 17,973 input tokens: about $0.0008, or $0.76 per 1,000 tasks.

• Learned once, then free. A task that worked is saved as a skill: the same goal from the same page then runs again with no model calls (24 of 24 replays in our runs), and where the page has changed, the agent takes over for that part and saves it again.

• You can see why. Every step comes with the probability behind it and the options it passed over, so a shaky step stands out.

• It uses the page like a person. Curved mouse paths, key-by-key typing, dropdowns picked from the open list, and a cookie banner is just another thing to click (it declines when it can).

• One loop for every site. There is no per-site code: the same loop looks at the page again after every step.

Related MCP server: Cloudflare Playwright MCP

Try it in two minutes

git clone https://github.com/clearcotelabs/clearcote-jet && cd clearcote-jet
pip install -e .
cp .env.example .env          # add TYPESAFE_API_KEY
python examples/run_task.py   # watch it find the next UK bank holiday, cursor drawn

Just the library: pip install git+https://github.com/clearcotelabs/clearcote-jet.

What it did in our runs

Live, in a visible Clearcote window, 29 September 2026:

The last row is a failure we kept on purpose: on a very long document it scrolled instead of using the table of contents. Jet now jumps to a section the goal names: on the same page it goes straight to "404 Not Found" in one step (13,793 input tokens, $0.0006, in 3 of 3 runs on 2 October 2026). For a goal that names no place it still scrolls, and stops after 12 scrolls in a row.

A GOV.UK run, step by step:

1. click  "Reject additional cookies"   p=0.85   decided in 361 ms
2. type   "next bank holiday" into "Search"   p=1.00
3. click  "Search GOV.UK"   p=0.93
4. click  "UK bank holidays"   p=0.99
done · 4 actions · 5 decisions · 14.8 s · 13,654 input tokens ≈ $0.0006

What it costs

• Decision model: $0.042 per million input tokens; output tokens are free. That is the published rate on 29 September 2026; set CLEARCOTE_JET_USD_PER_MTOK if yours differs.

• Measured (seven everyday tasks, three runs each, 2 October 2026): 10,372 to 30,031 input tokens per finished task, so $0.0004 to $0.0013, about a quarter fewer than before that day's request trimming. A replayed skill: 0.

• Not included: your Clearcote licence, and an optional text model, which bills with its own provider.

• Your own runs: every result carries usage (tokens, requests, estimated_usd), and python examples/estimate_cost.py totals everything in runs/ and projects the cost per 1,000 tasks.

Learned once, replayed for free

The first time a goal finishes from a start page, Jet saves how it did it as a skill: each step with how to find its control again (role, label, and its place among controls labelled alike; numbers in a label may change, so "87 comments" is found again as "213 comments"), how the run ended, and how the page's list of results is read. The next time the same goal is run from the same page, Jet replays the skill with no model calls. A cookie banner that doesn't show again is skipped. If the page has changed (a button renamed, a step that is gone, an ending that doesn't match), the agent takes over from that point, decides only what changed, and saves the skill again.

If the results came from a JSON request, the skill keeps that request too, and a replay reads the rows with it from inside the page, without clicking at all.

Replays are not much faster: most of a run is the browser and its human-paced input, not the model.

Skills are JSON files in ~/.clearcote-jet/skills (CLEARCOTE_JET_SKILLS). On the command line, --no-skill works a task out step by step and saves nothing; over MCP, browse(..., reuse=False) does the same, and list_skills / forget_skill manage them. A skill is for one goal from one page: another search term is another skill.

Results without a model

When a run finishes on a page with a list of results (search hits, products, listings), items holds its rows, read from the page's layout with no model: a title, a link, a price (the sale price, not a struck-out one) and an image, each found with a selector that works for most rows. The navigation, header and footer are left out.

Use it

Python

import asyncio
from clearcote_jet import Session, run

async def main():
    session = await Session.launch(headless=False)
    page = await session.new_tab("https://www.gov.uk/")
    result = await run(session, "Find the date of the next bank holiday in England and Wales.", page=page)
    print(result["status"], result["url"], result["usage"]["estimated_usd"])
    for step in result["trace"]:
        print(step["step"], step["kind"], step["action"], step["probability"], step["alternatives"])
    print(result["markdown"])
    await session.close()

asyncio.run(main())

Command line

clearcote-jet run --url https://docs.python.org/3/ --goal "Find the entry for asyncio.gather" --show-cursor

# keep one browser open and send it tasks
clearcote-jet browser --port 9222
clearcote-jet run --cdp http://127.0.0.1:9222 --url https://news.ycombinator.com/ --goal "Open the top story's comments"

Flags: --show-cursor (draw the mouse), --keep-open, --headless, --no-humanize, --profile DIR, --confirm (stop before a click that can't be taken back), --no-skill (don't learn or replay; see below).

As a tool for your AI assistant (MCP)

{
  "mcpServers": {
    "clearcote-jet": {
      "command": "clearcote-jet-mcp",
      "env": { "TYPESAFE_API_KEY": "...", "CLEARCOTE_LICENSE_KEY": "..." }
    }
  }
}

Your assistant gets these tools:

When browse stops (blocked, needs_input), the assistant can look with snapshot, do a step with act, and hand back to browse(goal, tab_id=...). act returns the new snapshot, so steps chain; if what a step depends on changed since the snapshot, it does nothing and answers stale. Tabs stay open between calls, several tasks can run at once in their own tabs (a second call on a busy tab answers busy), and the browser shuts itself down after a few idle minutes. Screenshots are taken without touching the page's DOM.

Settings

Put them in .env (see .env.example) or the environment:

Reading a result

How it works

1. Look. Jet lists the controls a person could use right now: visible, enabled, not hidden behind a pop-up, including those inside embedded frames (iframes), same-site or cross-site. Password fields can be filled but are never read: Jet only sees whether one is empty, never what it holds. When it gets stuck on a page (the model finds no way forward there, or it has scrolled three times in a row), it also lists the links inside the page's closed menus: navigation dropdowns, menu panels and collapsed sections, each named by its menu (Docs › Recommended settings). To click one, it opens the menu the way a person does, pointing at it (or clicking it, if pointing opens nothing), moves down inside the menu and clicks the link. It lists, too, what is scrolled out of view inside a box that scrolls on its own (a phone menu's panel, a dialog, a side list, a row of cards), which scrolling the page does not reach; it wheels over that box until the control is in view.

2. Decide. One request to the decision model picks the kind of step and the control together, with a probability for every option. The model only chooses from that list; it never writes code or coordinates.

3. Act. Jet checks that the page has not changed, then moves the mouse along a curved path, clicks, and types key by key. Page reads run in a separate, isolated context, so the page's own scripts don't see them. On a long page it can also jump to words from your goal, through the page's own anchor when there is one.

4. Answer. When the goal is met, the page is turned into markdown, and the sections around where the run ended are scored against the goal. A list of results on the page is read row by row, from its layout, with no model.

5. Remember. A finished task is saved as a skill (see below), so the next run of it needs no model.

Examples

Known limits

• On a long page it jumps to a section the goal names; when the goal names none, it may scroll rather than use a table of contents, and stops after 12 scrolls in a row with blocked.

• Links that open a new tab are not followed, and closed shadow roots, canvas apps, file uploads and CAPTCHAs are not handled. Controls inside iframes are; scrolling inside an iframe is not.

• Links inside closed menus, and controls scrolled away inside a scroll box, are offered only once a run is stuck on a page, and one level deep: a submenu inside a menu is not opened, nor a box scrolled away inside another box.

• done is the model's judgement. Check what matters.

• Jet only types words that appear in your goal (unless you configure a text model), so write the values into it.

Built for privacy, testing, research and lawful automation.

Development

pip install -e . pytest ruff
ruff check . && pytest tests -q            # offline: no browser, no model calls
python tests/e2e/check_browser_layer.py    # visible browser, scripted steps, a local test page
python tests/e2e/check_full_loop.py        # the whole loop with a stand-in for the model
python tests/e2e/check_frames.py           # controls inside same-site and cross-site iframes
python tests/e2e/check_mcp_tools.py        # snapshot and act on a local form (one live step if a key is set)
python tests/e2e/check_mcp_stdio.py        # the MCP server over stdio, as an assistant runs it
python tests/e2e/check_skills.py           # learn, replay, repair, lists, the request shortcut, confirm and find

License

MIT, see LICENSE.