Can an agent do real tasks through a screen and a keyboard?
- Progress report v056 — three tasks, one physical setup
- The agent sees only pixels; it acts only by moving a mouse and pressing keys
- No API access, no accessibility tree, no bridge software into the target machine
- Two machines: one runs the agent, one runs the task, and knows nothing about the test
- Every number in the underlying report links back to the raw frames and replies that produced it
- Today: what we found, what we corrected, and what's still open
One agent machine, one task machine, no software link
- The agent machine watches a live video feed of the task machine's screen
- It acts by sending mouse and keyboard signals to the task machine
- Both links are off-the-shelf hardware, not code
- Video in: a capture card, the kind used for recording gameplay
- Signals out: a USB device that presents itself as an ordinary keyboard and mouse
- The task machine runs completely unmodified
What the apparatus can and cannot see
- In: only what the capture card digitizes off the screen — nothing else
- No hidden state: no game memory, no browser page structure, no page source
- Out: mouse moves and key presses, the same signals a person's hands would send
- No shortcuts: the agent cannot click by an internal id or call a function directly
- Any advantage the agent shows has to come from watching and reacting in time
- The tradeoff: we also can't ask the target machine why something failed — only replay what the agent saw
Three tasks, one shared question: does it react in time?
- Task A: aim and fire at a vehicle in a driving game before it escapes
- Task B: press skip when a video breaks into a paid ad read
- Task C: click when a chart pattern completes
- Each is time-pressured differently, but each needs a decision inside a shrinking window
- Tasks B and C replay recorded video, so every model sees byte-identical input
- Task A runs live, because the agent's own shots change what happens next
Task A — find and destroy a moving vehicle: 0 of 24
- Headline: destroyed the vehicle in 0 of 24 episodes (n=24), under all three control setups tested
- Not passive — the agent acted in every single episode
- One setup: fired often (12.1 shots/episode) and hit nothing
- Other setup: moved the view constantly (14.6 moves/episode) but never fired once
- In that second setup, 115 of its 117 view moves were straight up or down — it tilted and almost never turned, and turning is how the target is found
- Three different behaviors, same result: no kills
- A mission left running with no agent at all also ends in a loss — a loss alone proves nothing (watched once, not recorded)
- The win/loss verdict is read off the end screen by a vision model, and right now that is the same model being tested — it only has to tell two fixed banners apart, but judge and subject are not independent
Task A — three setups: each one fixates on a different action
- Setup 1, screen-coordinate aim: 12.1 shots/episode, 8.2 view moves/episode, 0 destroyed
- Setup 2, camera-relative aim + zoomed sights offered: 0 shots/episode, 14.6 view moves/episode, 0 destroyed
- The zoomed sights were offered in the instructions but the hardware could not actually press the key for one of them — no agent has yet been able to use a sight
- Setup 3, same as setup 2 but with the aim-first instruction removed: 0 shots, and 7.4 presses/episode of the commander-sight key — a toggle it flicked on and off
- Setups 1 and 2 differ by three things at once, so that flip couldn't be pinned on any one of them
- Setup 3 removes only the instruction: firing does not come back, so the instruction was not the cause
- What repeats in all three: the agent picks one action early and repeats it
- Which action it picks differs between setups; with 8 episodes each and no repeat runs, we cannot say what decides that
Task B — sponsor-skip: catches every ad, over-presses by about 2x
- Headline: recall 1.00 (n=18) — every model tested finds the ad every single time
- Precision (crediting each skip properly): 0.24 to 0.41 across models — plenty of wasted presses
- One model is reliably worse than the other three, on 15-18 of the 18 videos
- The other three models are statistically indistinguishable from each other
- Reaction time is effectively tied across all four models (5.7 to 7.0 seconds)
- The agent over-presses roughly twice as often as needed, not six times, once the counting is fixed (next slide)
Task C — chart pattern: catches it, but fires far too often
- Headline: recall up to 0.90 (hosted models, n=6); the local model scores 0.00 recall (n=20)
- Precision stays low for every model that detects anything at all: 0.06 to 0.12
- The gap isn't seeing the pattern — it's clicking again after it's already been caught
- The local model's zero recall is a separate, real gap: it isn't spotting the pattern at all
- With no memory of its own past clicks, each fresh decision re-fires on the same event
- A simple rule against repeating a click too soon after the last one would fix most of this
Corrections made to previously reported numbers
- Task B over-pressing was charged too harshly: the skip key needs about 3 presses to clear a long ad read, so a chunk of "duplicate" presses were actually required; the fixed number is roughly double the earlier figure, not six times worse
- A claim that the local model was 3x faster came from 5 samples on a short test prompt versus 453 real decisions on the task's real prompt; measured the same way, both take about the same time (~690ms)
- Task A's episode end was cut 5 seconds early by a guess based on screen color and image sharpness; reading the game's own end-of-mission message moved the cut and changed the decision counts
- A Task C tradeoff calculation was wrong in a script that was never saved to the project; the saved scoring code had been silently reporting zero because it was checking for key presses on a task that uses mouse clicks
- A claim that "checking faster stops helping" used the wrong kind of average and reversed once corrected properly
- Reaction times were labelled "median" but computed as an average of medians; the real medians are up to 0.6s lower
- Twelve comparison numbers were typed into the report by hand instead of computed; three were wrong, including two differences printed with the sign backwards
- Every correction above is logged with what changed and why in FINDINGS.md and RETRACTIONS.md
Systems result: local and hosted decide at about the same speed
- Matched measurement: same prompt, same frames, same task, for both
- Local model, on-prem GPU: about 690ms median per decision
- Hosted API model: about 693ms median per decision — no meaningful difference
- The case for running locally isn't speed — it's no network dependency, no per-call cost, and no account that can run out of credit mid-experiment
- The full live loop (capture card to hardware input, real hardware) measured about 949ms end to end
- This was the one speed claim that had survived many earlier corrections — it is now also withdrawn
The same failure shape shows up in all three tasks
- Each decision the agent makes starts from scratch, with no memory of what it already did
- Task A: it settles into one action — firing, or tilting the view — and repeats it
- Task B: it presses skip repeatedly through one ad instead of once
- Task C: it re-clicks a pattern it has already caught
- We can't yet tell how much of this is "no memory" versus the visual task itself being hard — that split hasn't been tested
- Giving the agent a short window of its own recent actions is the natural next experiment
What this setup still can't tell us
- Tasks B and C replay recorded video, so an action never changes what the agent sees next
- Task A can't be replayed, so each episode is one live shot, not a repeated trial under identical conditions
- Sample sizes are small in places (6 to 20 episodes), so some numbers carry wide uncertainty
- A scoring bug that quietly reports zero when the agent's action set changes has appeared three times in this project; caught before publishing this time, but it's a recurring risk in our own tooling, not just a one-off
- The Task A two-setup comparison mixes three changes together — see the earlier slide
- One action offered to the agent turned out not to be performable by the hardware at all; the runner now checks its whole action list against the device before starting
- Every known gap here is written down, not papered over, in FINDINGS.md
Next steps
- Run Task A's three changed factors separately: aim control, zoomed sights, and the aim-first instruction
- Add a short-memory condition to test whether repeated actions are a memory gap or a difficulty gap
- Extend Task B's video window so more than one ad read appears, so recall stops sitting at a perfect 1.0
- Restore hosted-API access to finish the checking-rate comparison on more than one model
- Time key-press and click actuation separately from move-only actuation
- Keep logging every correction the same way — that habit is the point of this project
Bottom line
- An agent that only sees pixels and only moves a mouse and keyboard can react in time, but not accurately
- It catches almost everything it's asked to catch (Task A aside) and over-acts on most of it
- Local and hosted models turn out close in both speed and accuracy; earlier claims of a gap did not survive a fair, matched measurement
- All three tasks share one failure: repeating an action instead of remembering it already worked
- Every number here traces back to a recorded frame and a logged decision, including the ones we later had to fix
- Full detail, every correction included: reports/latest.html and FINDINGS.md