H Company's Holo3.1 Hits 78.85% on Desktop Tasks, Beating OpenAI and Anthropic

Paris-based H Company has officially launched its Computer-Use Agents API out of early access and into open beta. The pitch is simple: you describe a task in plain English, H provisions a cloud browser or desktop environment, runs the agent, and hands you back a result. No sandbox to spin up, no agent loop to write, no model to host.

The model behind it

The API is powered by Holo3.1, H's latest vision-language model family built specifically for GUI control. With a score of 78.85% on the OSWorld-Verified benchmark, Holo3 establishes a new state of the art on the leading desktop computer-use benchmark. OSWorld-Verified is worth understanding: it's the leading benchmark for evaluating AI computer use, and unlike benchmarks that score on output text, OSWorld tests execution -- the agent must complete real tasks on a real computer, and success is verified by checking the actual state of the system afterward. To put the score in context: scores above 40% were considered state-of-the-art until recently, and previous leading models from Anthropic and OpenAI sat in the 60-65% range.

Holo3 achieves this with only 10B active parameters (122B total), so at a fraction of the cost of large-scale proprietary models such as GPT-5.4 or Opus 4.6. The architecture is a sparse Mixture-of-Experts (MoE) model -- meaning only a subset of the model's parameters activate per token, keeping inference cheap despite the large total parameter count. Holo3.1 also delivers more than a 25% improvement over Holo3 when evaluated inside H's Holotab product harness.

How it was built

Holo3 was built using an agentic flywheel, trained to execute real-world workflows within synthetic enterprise environments. The key training innovation is what H calls the Synthetic Environment Factory: this proprietary factory reproduces the reality of enterprise systems, and environments are automatically built using coding agents that program websites from scratch based on scenario specifications, producing verifiable tasks of varying difficulty that are validated end-to-end with verification scripts. The training pipeline also applies out-of-domain augmentation to programmatically extend scenarios and ensure Holo3 can handle the unexpected, plus curated reinforcement learning where every data sample is carefully filtered to maximize performance.

To better support teams deploying Holo inside third-party agent stacks, Holo3.1 introduces native support for function-calling protocols in addition to the structured JSON outputs already available in Holo3. To further enable local and on-device inference, H also released new model sizes including small models at 0.8B, 4B, and 9B for cost-effective and private deployment, in addition to the larger 35B-A3B model for state-of-the-art performance.

What you're actually getting

The API surface is clean. An agent is a reusable configuration: a model, a set of instructions, optional skills (reusable instruction fragments), and optional subagents for delegation. You fire a session against a task, and the platform handles everything in between. H ships pre-built agents like h/web-surfer-flash so you can be productive immediately:

# pip install hai-agents
from hai_agents import Client
client = Client()
result = client.run_session(
    agent="h/web-surfer-flash",
    messages="Find the cheapest direct flight from CDG to NRT this Saturday.",
)
print(result.answer)

Beyond Python, there are TypeScript SDKs, a CLI (hai run), an MCP server, and a raw REST API. It connects to whatever you're already using: Claude, Hermes, Cursor -- one API key to start, and no agent loop to write yourself, no sandbox to provision. H says most people have a first agent live in under 30 minutes.

The three use cases that keep coming up

H has been running early access and a hackathon before this launch, and three categories of tasks emerged as the clearest wins:

• QA Testing. Point a browser agent at a live URL and it tests your app the way a real user would, returning a verdict and findings you can wire straight into CI.
• Web Extraction. Describe the data shape you want, and the agent navigates any web page and returns typed, structured output -- no scraper to maintain.
• Web Actions. Describe what you want done on any site, and the agent clicks, fills in fields, and verifies the result actually worked.

Some of the more creative examples from the hackathon: one agent searches Craigslist in a cloud browser for apartments and posts back a shortlist with photos and prices, while a second drives the native WhatsApp desktop app to message landlords and book viewings -- no API anywhere in the stack. Another pattern is accessibility testing: run a swarm of agents with deliberately degraded vision and motor control against a live site, and get back a heatmap of where users give up.

What it struggles with

The benchmark number is impressive, but 80% accuracy means roughly 1 in 5 tasks still fails. In independent testing, web form filling and structured spreadsheet tasks worked reliably, but multi-app workflows and anything triggering unexpected popups regularly broke. It is production-ready for batch tasks where a human reviews output -- scraping, data extraction, form filling at scale -- but not for critical workflows that need to run without oversight. The API is also explicitly in beta, with the docs noting it is still evolving. Remote desktop VMs (Mac, Windows, Linux) are on the roadmap but not yet live.

Pricing and availability

The API is available now at platform.hcompany.ai with a free tier to start. The flagship 122B model is available through the API at $0.40/M input and $3.00/M output tokens, while the 35B open-source model is available at $0.25/M input and $1.80/M output. That works out to roughly $1.50 per 1,000 automated tasks -- about 10x cheaper than Claude Computer Use at the same workload. The 35B open-weight model is also available on Hugging Face under Apache 2.0 for teams that want to self-host.

Why this matters beyond the headline

The real shift here is the abstraction level. Most computer-use implementations today require you to manage your own browser sandbox, write the action loop, handle retries, and stitch together a vision model with a controller. H is collapsing that entire stack into a single API call. Holo3.1 improves robustness across the three dimensions that matter most in production: environments (web, desktop, mobile), agent frameworks, and deployment targets -- a major step toward universal computer-use agents that can operate across environments and integrate into any agent stack.

The industry context matters too. There's still a class of task that breaks every automation: legacy enterprise software with no API, desktop apps that predate REST, multi-step workflows that cross five different UIs. Traditional RPA tools handle this with brittle screen-coordinate scripts that break every time the UI changes. A model that actually understands what it's looking at -- rather than clicking on hardcoded pixel coordinates -- is a fundamentally different approach. The question is whether 80% reliability is good enough for your specific workflow. For supervised batch tasks, it probably is. For unattended production pipelines, it's not quite there yet.