Hark Handoff: What a Cheap Computer Use Agent Means for SMBs

By Lazar Milicevic · Published October 14, 2026 · 10 min read

You have a list of web tasks that no API covers: logging into a vendor portal to pull invoices, messaging candidates on LinkedIn, booking travel, checking a supplier's stock page. Computer use agents (CUAs) promise to do these by driving a browser like a person would, but until now they have been too slow, too expensive, or too flaky to trust with real work. Hark's new agent, Handoff, claims to move the price and speed numbers a long way, so it's worth separating what is verified from what is marketing before you rebuild anything around it.

What Hark actually announced

Hark announced Handoff, a computer use agent it says is among the top performers at navigating the open web on a user's behalf. Its launch examples are ordering dinner on DoorDash, booking flights on United and Delta, and messaging job candidates on LinkedIn, all done autonomously (VentureBeat).

The basics:

• Who is behind it. Hark is Brett Adcock's fourth company. He previously co-founded Vettery, Archer Aviation and Figure AI, seeded Hark with $100 million of his own money, and is CEO of both Figure and Hark.
• When. Handoff was introduced on August 5, 2026 as a research preview (Startup Fortune). Hark Pro, a consumer app built on Handoff, launched on October 6, 2026, free on web, iOS and Android, with paid tiers at $20 a month for 2x usage and $100 a month for 10x usage (Bloomberg).
• How it works. For each task, Handoff spins up a dedicated virtual computer with its own browser, file system and terminal. It connects to your existing accounts and logs in for you, with no official API required (Enera Labs). Note that Enera Labs is a lower-quality secondary source, so treat the architecture details as reported, not confirmed.
• Concurrency. Handoff in Hark Pro can run up to six browsers at once (Quartz).
• Model. Hark has focused on post-training rather than training a base model from scratch, and has not identified the underlying model (Smart Content Report).

What I could not confirm: whether Handoff is available as a standalone API or developer product for SMB integration. Hark Pro runs on it, but a public API with a published per-task price was not confirmed in anything I read. One secondary source says no specific pricing was published on launch day.

The benchmark claims, read carefully

Hark says Handoff scored 97.7 on Online-Mind2Web, a human-evaluated web-agent benchmark. The scores it gives for rivals are 92.8 for GPT 5.4, 84.1 for Claude Opus 4.8 and 69 for Gemini 2.5 Pro. Hark's own article says Handoff took the top spot on the human-evaluation leaderboard, and that across three browser benchmarks it beat GPT 5.4 by 8 points on average and Opus 4.8 by 2 points (Hark).

Three caveats matter before you act on these numbers:

1. The comparison set is a generation old. VentureBeat notes that Hark compared itself against prior-generation frontier models. Newer models have no published Online-Mind2Web results, so a "best ever" claim can't be checked against the strongest systems available today. I'm not stating it as fact, and you shouldn't either.
2. Hark's own harness tells a mixed story. On WebTailBench v2, run in Hark's own harness, the reported scores were Handoff 68.6, GPT-5.5 72.3 and Claude Opus 4.8 66.9. On Hark's internal evaluation: Handoff 83.2, GPT-5.5 75.2, Opus 4.8 80.5 (Progressive Robot). Both evaluations use Hark's own test harness and haven't been independently confirmed. Note that GPT-5.5 scored higher than Handoff on WebTailBench v2. A single number doesn't make Handoff a clear winner.
3. Benchmarks aren't your workflow. Online-Mind2Web measures a set of public-web tasks. Your vendor portal with a quirky MFA flow and a CAPTCHA every third login is a different test.

The honest summary: Handoff looks competitive with frontier agents on browser tasks, possibly ahead on some, and nobody outside Hark has verified the margin.

The price story: real, but incomplete

This is the part that changes SMB math, if it holds up. Hark's token pricing for Handoff is $0.18 per million input tokens and $2.37 per million output tokens. GPT 5.5 is $5 and $30 by the same comparison (VentureBeat). VentureBeat also reports that Anthropic's Opus 5 has the same list price as its predecessor, $5 per million input tokens and $25 per million output tokens, so Handoff's token-price advantage would hold against the current frontier.

Two things to keep straight:

• Mixed comparisons. Hark's benchmark comparison is against GPT 5.4, while its price comparison is against GPT 5.5. Don't blend them into one "cheaper and better than X" sentence.
• These are Hark's claims about serving cost, not a published SMB price list.

Here is why token rates alone mislead. eWeek cautions that they don't capture the total cost of completing a browser task, which includes retries and supporting infrastructure (eWeek). A browser agent burns tokens on screenshots or page state every turn, and a failed run costs the same as a successful one.

Here is a way to model it. The numbers below are illustrative round numbers, not Hark measurements:

# Illustrative only: assumed token counts, NOT measured values.
# Replace with numbers from your own pilot runs.

def cost_per_task(turns, in_tok_per_turn, out_tok_per_turn,
                  in_price_per_m, out_price_per_m):
    input_cost = turns * in_tok_per_turn * in_price_per_m / 1_000_000
    output_cost = turns * out_tok_per_turn * out_price_per_m / 1_000_000
    return input_cost + output_cost

def effective_cost(single_run_cost, success_rate):
    # Failed runs still cost money; expected cost per *successful* task.
    return single_run_cost / success_rate

# Assumption: a 30-turn task, 8,000 input / 300 output tokens per turn
handoff = cost_per_task(30, 8000, 300, 0.18, 2.37)
frontier = cost_per_task(30, 8000, 300, 5.00, 30.00)

print(f"Handoff list-price run:  ${handoff:.3f}")
print(f"$5/$30 list-price run:   ${frontier:.3f}")
print(f"At 80% success: ${effective_cost(handoff, 0.80):.3f} "
      f"vs ${effective_cost(frontier, 0.80):.3f}")

With those assumed inputs, token cost per task lands in cents for the cheap model and tens of cents for the expensive one. That gap is real, but it only matters if the cheap agent finishes the job at a comparable rate. Plug in your own turn counts and success rates from a pilot before believing any of it.

Speed: model latency isn't task latency

Hark reports model latency of 0.8 seconds per turn. Hark's own launch article is explicit that this is model latency only, and that browser latency adds roughly 10 seconds (Hark).

That distinction matters for planning. If a task takes 30 turns and each turn carries roughly 10 seconds of browser overhead, you're looking at minutes, not seconds, regardless of how fast the model thinks. (That's arithmetic on a hypothetical 30-turn task, not a Hark figure.)

The Hark Pro DoorDash demo showed this. Handoff spent several minutes navigating checkout and then paused for the user to confirm payment. The demonstrator said they could have ordered faster themselves (Superpower Daily).

That tells you which tasks fit a CUA:

Build vs buy: how the math shifts for a small team

Before cheap CUAs, you had three options for a no-API web task: pay a person, write a brittle Playwright script, or skip it. Cheap agents add a fourth. Here is how I'd frame the decision.

Scripts still win for stable, high-volume flows. If you hit the same page 500 times a day and its layout rarely changes, a deterministic script costs almost nothing per run and doesn't hallucinate. An agent is overkill.

Agents win where pages vary or change often. Pulling data from many different vendor sites, each with its own layout, is where scripts rot and an agent adapts. That's the case where token price drops start to matter.

Buy beats build for the agent itself. Training or post-training a computer-use model is not an SMB project. The decision is which agent to rent and how to wrap it. If Handoff gets a public API, it becomes one more option in a pluggable layer rather than something to hardwire in.

That last point is the practical takeaway: design for swappability. Put the agent behind a thin interface so you can change providers when prices and benchmarks move, which they will.

# A thin provider-agnostic wrapper. Provider classes are placeholders;
# wire in whichever agent API you actually have access to.
from dataclasses import dataclass

@dataclass
class TaskResult:
    ok: bool
    output: str
    needs_approval: bool = False
    cost_usd: float = 0.0

class BrowserAgent:
    def run(self, goal: str, allowed_domains: list[str],
            max_turns: int = 40) -> TaskResult:
        raise NotImplementedError

def run_with_guardrails(agent: BrowserAgent, goal: str,
                        domains: list[str]) -> TaskResult:
    result = agent.run(goal, allowed_domains=domains, max_turns=40)
    # Anything that spends money or sends messages gets a human gate.
    if result.needs_approval:
        notify_owner(goal, result)   # Slack/email; you implement this
        return result
    return result

Three design choices in that sketch carry most of the safety value: a domain allowlist, a hard turn cap so a confused agent can't loop and burn tokens, and an approval gate on anything irreversible.

Security and data handling: the open questions

This is where I'd slow down. Hark has not identified the underlying model or detailed who can access files on users' virtual computers. It calls Handoff a technical preview and says it will share more security information before broader availability (Smart Content Report). Some secondary sources describe an "encrypted credential vault," but I can't verify that from a primary source, so don't treat it as established for business use.

An agent that logs into your accounts has the access of the account it logs into. Practical rules for any CUA, Handoff or not:

• Use dedicated accounts with least privilege. Create a read-only or role-limited login for the agent rather than handing over an admin credential.
• Keep it away from payment methods unless a human approves each purchase.
• Don't put regulated or customer-sensitive data through a preview-stage agent until the vendor publishes data-handling terms.
• Log everything. Record the goal, the pages visited and the outcome so you can audit what the agent did.
• Check the target site's terms of service. Some prohibit automated access.

Hark's gaps here aren't unusual for a research preview, but "preview" is the right level of trust for now.

A pilot plan you can run this month

Don't rebuild a workflow on launch-week claims. Run a measured pilot instead:

1. Pick 3 tasks with no API, moderate volume, and low blast radius if wrong (data retrieval beats sending messages).
2. Define success per task: exact output, acceptable error rate, maximum minutes.
3. Run each 20+ times against two or three agents, including whatever Claude-based setup you already use, and record success rate, turns, wall-clock time and token cost.
4. Compute cost per successful task, not cost per run (the effective_cost function above).
5. Add the human gate for any action that spends money or contacts a person.
6. Re-run quarterly. Prices and benchmark standings shift quickly, and the agent that's cheapest today may not be in three months.

A simple tracking sheet is enough:

pilot:
  task: "Download monthly invoice PDF from Vendor X portal"
  runs: 20
  agents:
    - name: agent_a
      successes: 0      # fill in
      avg_turns: 0
      avg_wall_clock_min: 0
      total_token_cost_usd: 0
    - name: agent_b
      successes: 0
      avg_turns: 0
      avg_wall_clock_min: 0
      total_token_cost_usd: 0
  decision_rule: "pick lowest cost per successful task with >= 90% success"

If an agent can't clear your success bar in a pilot, the token price is irrelevant.

How BizFlowAI approaches this

For clients, I treat a computer use agent as one component in a larger workflow, not the workflow itself. The pattern that holds up is deterministic automation for anything with an API or a stable page, a CUA only for the long tail of no-API web tasks, and Claude-based steps for the judgment work in between, such as classifying an email or drafting a reply. Every agent sits behind a swappable interface with a domain allowlist, a turn cap and a human approval step on anything that spends money or contacts a person.

If cheaper agents like Handoff reach a stable, documented API, that changes which tasks are worth automating, and I'd rather help you measure it on your own SaaS stack than guess.

Work with BizFlowAI

If you'd rather have this built for you, that's what we do: production AI automation for solo founders and small teams — agents, integrations, and document pipelines that actually ship.

Request a free discovery call — 30 minutes, we map the highest-ROI automation in your workflow. No pitch deck, just engineering.

More guides like this on the BizFlowAI blog.