Yappy vs HeyClicky on an involved task: computer use and browser use
Two macOS computer-use agents, the same Notion job application, the same answers file, the same prompt. Yappy finished about 5× faster, with a third of the actions, a ninth of the tokens, and about a seventh of the cost — and it never took over the screen.
A better run, at a fraction of the cost
Both agents reached the same completeness: every field filled except the resume, which needs a native file-upload dialog, and neither submitted. So this is not about one agent doing more — it is about how much time, effort, and disruption it took each one to reach the same finished form.
End-to-end time
From trigger to the agent reporting the form done. Lower is better.
Of HeyClicky's 13m 14s, about 2m 20s was spent stopped, waiting for the user to bring the form to the current Space and tell it to continue. Yappy waited on no one. The 18 September bar is the plan build with the Jev lane, form opened first — see the update below.
Actions taken
Steps the agent performed to fill the form. Fewer means a more direct path. Lower is better.
HeyClicky repeatedly re-read the whole screen as it worked; Yappy filled the fields directly. In the 18 September run, 5 of the 22 actions were chosen by Jev.
Input tokens consumed
Total model input across the whole task, in millions. Lower is cheaper. Both are mostly cached reads.
Working from the screen means sending the model a picture of it again and again; reading the page directly keeps the context small. The 18 September run used 0.32M for Opus and 0.07M for Jev.
Estimated cost of the run
Both runs' tokens priced on the same published rate card — $3 per million uncached input, $0.30 per million cached, $15 per million output — so this reflects token volume, not either vendor's private pricing. Lower is better.
The same task cost about seven times more to run with HeyClicky, almost entirely because it re-sends the screen to the model on nearly every step. Jev's five decisions in the 18 September run cost $0.003 of the $0.24.
The full scorecard
| Measure | HeyClicky | Yappy | Yappy + Jev 18 Sep |
|---|---|---|---|
| End-to-end time | 13m 14s | 2m 38s | 1m 54s |
| Active execution time | ~10m 54s | 2m 38s | 1m 54s |
| Time waiting on the user | 2m 20s | 0s | 0s |
| Manual "continue" needed | Yes, after an off-Space stall | None | None |
| Actions taken | ~104 | 32 | 22 (5 chosen by Jev) |
| Input tokens (mostly cached) | 11.24M | 1.21M | 0.39M (0.07M of it Jev) |
| Estimated cost of the run (same rate card) | ~$4.24 | ~$0.60 | ~$0.24 |
Behaviour and reliability
| Property | HeyClicky | Yappy | Yappy + Jev 18 Sep |
|---|---|---|---|
| Works with the window in the background | No — needs it foregrounded | Yes | Yes |
| Works when the window is on another Space | No — stalled and asked for help | Yes | Not exercised |
| Leaves your screen and focus alone | No — brought the browser forward | Yes | Yes |
| Reused a single browser tab | No — opened several windows of the form | Yes | Yes |
| Completed the resume upload | No (file picker failed) | No (handed off) | No (handed off) |
Update, 18 September 2026: the same form with the Jev decision lane
We filled the same Ashby form again on a development build of Yappy (0.4.59) running on the Yappy plan — inference through OpenRouter rather than a local Claude Code install — with a new fast lane in front of the agent: Jev, TypeSafe's decision model, is asked one structured question per step (which operation, on which control, and whether the goal belongs in the front window at all) and answers in a few hundred milliseconds for a fraction of a cent. Only a typed value is written by a chat model; anything the lane cannot settle is handed to the full agent.
Setup differed from the 6 September run in two ways, both deliberate: the form was opened and brought to the front first, and the answers rode inside the instruction rather than in a file, because the lane reads windows, not files. Same fields, same values, same "do not submit".
What Jev did. Five decisions in ten seconds, each in 275–690 ms, for $0.003 in total. It judged the window a fit (0.93), then chose Full Name, Email, Phone and the Location typeahead — the first four fields, in form order, with the right value each time. Every one of those writes failed: Chrome's React inputs ignore a value set through the accessibility API, so the lane saw four no-ops, confidence fell to 0.21, and it handed off.
What the full agent did. Claude Opus through OpenRouter took the same form over the DOM route and finished it in 11 model requests and 12 page calls: 0.32M input tokens (95% cached reads), 6.0k output. End to end, 1m 54s and about $0.24 on the same rate card. Read back through the page afterwards: name, email, phone, location, LinkedIn and every choice field held the expected values; the resume was empty, as in both earlier runs; nothing was submitted.
Two honest notes. Jev's decisions were right and its writes were not, so this is a measurement of the agent it handed to, made quicker by a pre-opened tab, not a measurement of Jev filling a form — that needs the lane to write through the page rather than the accessibility tree, which is the next change. And an earlier attempt the same morning, with the original file-based instruction and a terminal in front, went the other way: Jev correctly declined the window in 251 ms and the full agent took 4m 41s and $0.65 over the plan path, slower per step than the 6 September Claude Code path. n=1 in every column.
Read-back used Yappy's own page tool over the live tab. Timings, tool counts and tokens are from the app's log for session s-9-52079.
What we tested
The task was a genuine, live job posting: Notion's Software Engineer, Developer Platform application, hosted on Ashby. It is a long single-page form — name, email, phone, location (a typeahead), LinkedIn, resume upload, pronouns, two yes/no policy questions, a "how did you hear about us" multi-select, and the voluntary equal-opportunity self-identification groups.
We wrote the answers once into a Markdown file and gave both agents the same instruction: open the application link from that file in a new Chrome tab, fill every field from the file, do not submit, and report what was filled. The resume was a real file path, so both agents faced the same file-upload step.
Methodology
The goal was a fair, reproducible, execution-based comparison rather than an impression. Everything ran on one Apple-silicon MacBook Pro on macOS, back to back, in a quiet window.
Same task, same prompt, isolated runs
Each agent ran alone on a freshly closed form, so neither could write into the other's fields. (Running them at the same time confirmed why that is necessary: both target the same URL in the same browser and overwrite each other. Those runs were discarded.)
What counts as "done"
We scored completion the way OSWorld2 does — by inspecting the final state, not by trusting the agent's claim. After each run we read every field's value straight from the page and checked it against the answers file. "Filled and confirmed" means the value was actually there.
What we measured
For each run we recorded three things from the run on the test machine: the wall-clock time from trigger to the agent reporting done, the number of actions it took to fill the form, and the model tokens it consumed. We turn the tokens into an estimated dollar cost by pricing both runs on the same published API rate card (shown with the cost chart above), so cost reflects token volume rather than either vendor's contract. We separate active execution from time spent waiting on the human, because one agent needed manual help mid-task and the other did not. How each agent is started also differs and is reported as a result: Yappy is started hands-free by voice or a keypress and then runs on its own; HeyClicky is started the same hands-free way but, once running, needs the form kept in front of it.
Limits, stated up front. This is one run per agent on one task on one machine — an honest, transparent head-to-head, not a statistical benchmark. Model choice, network, and the live form all add variance. We publish the method and the raw figures so it can be repeated and challenged. HeyClicky is a capable, well-built product; the differences here are about how each approach behaves on this specific background-form-fill task, not a verdict on everything either app does.
Why the gap exists
The difference comes down to where each agent does its work.
HeyClicky works in the foreground
HeyClicky operates on the window you are looking at, driving the screen the way a person would. That is general and flexible, but it needs the target window on screen, in front, on the Space you are on. In our run it brought the browser forward repeatedly, opened the same form in several windows, and stopped outright when the form was on another Space until we moved it over and told it to continue.
Yappy works in the background
Yappy fills the page directly without bringing the window forward, so it reaches a tab that is minimized or on another Space and never steals your focus. That is why it finished in one quiet pass while you kept working in another app.
Neither agent reaches your logged-in browser through raw remote debugging: since Chrome 136, Chrome ignores the remote-debugging switches on your normal profile as an anti-cookie-theft measure.1 Both therefore work through the browser's ordinary surfaces instead.
Looking for a HeyClicky alternative?
If what drew you to HeyClicky was a Mac agent you can talk to that actually operates your apps, Yappy does the same class of work and adds the thing a background agent is supposed to have: it gets out of your way. You hold a key, say what you want, and it works in the apps you already have — minimized, on another Space, while you keep typing. On this job-application task it was about five times faster and never once interrupted the person who asked for it.
Sources
- "Changes to remote debugging switches to improve security," Chrome for Developers blog — from Chrome 136, the remote-debugging switches are ignored on the default browser profile.
- OSWorld: Benchmarking Multimodal Agents for Open-Ended Tasks in Real Computer Environments (arXiv:2404.07972, NeurIPS 2024) — the execution-based evaluation model this test follows. See also OSWorld 2.0 (arXiv:2606.29537).
- HeyClicky — product and public changelog. The foreground and Space behaviour described here is what we observed during the test run on 6 September 2026.
- Yappy — Yappy 0.4.32. All timings and counts are from each agent's run on the test machine, 6 September 2026; the method above is sufficient to reproduce them.
- TypeSafe System One (Jev) — decision model used by the 18 September 2026 re-run, reached through OpenRouter's decisions endpoint. Yappy 0.4.59 development build on the Yappy plan; timings, tool counts and tokens from the app's own log for sessions s-9-52079 (the tabled run) and s-6-51012, priced on the same rate card as the table.