General-purpose computer use gives an agent the reach to move beyond pre-integrated tools. Reliable end-to-end task completion determines whether it can truly function as a digital employee.
Why most agents still stop at an intermediate output
Many products are now described as agents, but very few are close to being digital employees. Most remain strongest at generating content: answering questions, writing articles, building slide decks, producing code, or performing fixed actions inside a small set of pre-integrated tools.
They may deliver a report, a codebase, or a set of instructions, yet remain unable to carry out the real work that comes after the report, the code, or the recommendation.
This is not only a question of intelligence. A more immediate limitation is that most agents still cannot operate a computer broadly enough to reach every step required by the task.
Real work is distributed across websites, files, terminals, desktop applications, communication tools, system dialogs, and authenticated accounts. An agent may know exactly what should happen next, but if it cannot open the relevant software, interpret its interface, enter information, respond to feedback, and continue across applications, it must hand the task back to a person.
The ability to operate software that has not been specially integrated is therefore a major dividing line between an agent that produces intermediate outputs and one that can begin to deliver end-to-end results.
This article identifies promising foundations from public documentation. It is not yet a Liuma hands-on ranking or a final delivery recommendation.
What should a complete digital employee be able to do?
As a long-term capability boundary, we believe a digital employee should be able to complete any task that a human can complete on a computer, within the user’s authorization and the limits of the available hardware.
Completion does not mean producing a guide that tells the user what to do next. It means understanding the objective, operating the required software, moving between tools, responding to execution feedback, and continuing until the user’s intended outcome has been achieved.
Consider a request to purchase two suitable computers within a given budget. If the relevant platforms offer no usable API, connector, or dedicated automation, an agent without general-purpose computer use may still analyze the requirements, search products, and write an accurate procurement report. The user must then log in, contact sellers, confirm inventory, place the order, pay, track delivery, and handle exceptions.
Even if the report is completely correct, it remains an intermediate output when the original task was to complete the purchase.
An agent with sufficiently broad computer access has the opportunity to continue: investigate products and suppliers, verify prices and stock, calculate total cost, contact sellers, present a decision, request human authorization at the payment gate, place the approved order, track delivery, resolve exceptions, and close the task after receipt and acceptance.
The shift is not merely from bad content to correct content. It is from helping the user think about the work to actually getting the work done.
General-purpose computer use is still rare
Agent does not mean computer operator. Most products still work primarily inside a chat window, code repository, terminal, browser, or limited tool collection.
Browser automation is valuable, but it is not the same as operating a complete computer. By itself, it does not naturally cover local applications, system settings, file pickers, permission dialogs, peripherals, or workflows that move beyond the web.
General-purpose computer use is not always the preferred execution path. A stable API, MCP integration, command-line tool, or dedicated browser automation can be faster and more reliable when one is available. The importance of general-purpose computer use is that it extends the agent’s reach when no dedicated interface exists.
Only a small group of leading agents are beginning to combine broad computer operation with strong reasoning and a persistent execution loop. Codex and Claude Code are among the most important current candidates.
- Strong task understandingThe agent must identify the intended outcome, not merely restate the instruction.
- Terminal, file, and browser accessIt must perform structured digital work through the most reliable interface available.
- Desktop and Computer UseIt must operate real software when no suitable API or pre-built integration exists.
- Cross-application continuityIt must carry context and responsibility across websites, files, desktop applications, and communication tools.
- Persistence and recoveryIt must continue after network interruptions, restarts, permission failures, and tool errors.
- Outcome verificationIt must determine whether the actual objective has been reached instead of treating an intermediate step as completion.
Having hands and feet is not the same as finishing the job
General-purpose computer use expands the range of actions an agent can take. It allows the agent to cross interfaces that were not prepared for automation and makes broader end-to-end delivery possible.
It does not guarantee success. An agent may be able to open websites, operate applications, and run commands while still misunderstanding the objective, choosing the wrong path, stopping after an exception, repeatedly asking the user what to do next, or claiming completion when the task remains unfinished.
A genuine digital employee must therefore pass two separate gates.
Reasoning without action stops halfway. Action without reliable task closure is only a more flexible form of automation.
- Gate one: Every critical action is reachableWhether through an API, MCP, terminal, browser, or desktop interface, the agent must be able to perform every action required by the task. If a critical step still requires the user to take over, the agent will usually deliver an intermediate output rather than the final result.
- Gate two: The objective is closedOnce the actions are available, the agent must organize them into a complete process, handle exceptions, verify the outcome, and continue until the user’s real objective is achieved.
Four levels of digital-employee capability
Current agent products can be understood through four broad levels. These are not fixed product categories: the same product may operate at different levels depending on its configuration, permissions, tools, platform, and task.
A large share of agent evaluations still stop at the first level and treat the existence of a deliverable as success. More tool-oriented agents operate at the second level. Only a small number are beginning to enter the third. The fourth remains an objective that must be demonstrated repeatedly through real work.
This also explains why earlier generations of agents often delivered articles, reports, code, and operating instructions instead of final outcomes. The problem was not only whether the generated material was correct. Their ability to act ended before the work did.
- 1. Content generationProduces articles, presentations, images, websites, code, or other artifacts.
- 2. Local executionPerforms actions inside a terminal, browser, repository, or small set of integrated tools.
- 3. Full computer executionOperates websites, local applications, and system interfaces, carrying work across tools as a person would.
- 4. General task closureSustains action across broad computer-based work, handles exceptions, verifies the result, and remains accountable for the intended outcome.
The primary metric: independent end-to-end task completion
A digital-employee foundation should not be judged primarily by model size, number of tools, a polished Computer Use demonstration, or the number of clicks performed in one session.
The primary measure should be its independent end-to-end completion rate: the proportion of valid assigned tasks that achieve the real intended outcome without user takeover, excluding human actions that legitimately require authorization.
Whether every critical action is reachable determines if the agent can own a specific task. General-purpose computer use determines how far that ownership can extend beyond specially integrated software. Independent end-to-end completion determines whether the system is actually qualified to function as a digital employee.
Independent end-to-end completion rate = valid tasks that achieve the intended outcome without user takeover, excluding required human authorization ÷ all valid tasks assigned.
- Computer-task coverageHow much of the computer operation required by the real task can the agent perform autonomously?
- False-completion rateHow often does the agent claim success when the user’s intended outcome has not been achieved?
- Human-takeover rateOutside legitimate approval gates, how often must the user personally continue or repair the work?
- Blocker visibilityWhen something goes wrong, does the agent report the problem promptly and accurately?
- Recovery rateCan the task continue after a network interruption, restart, permission failure, or tool error?
- Cost per closed taskHow much time, model usage, infrastructure, and human attention are consumed for each task that is genuinely completed?
Codex and Claude Code: the leading general computer-use candidates
Public documentation can establish which capabilities a product offers. It cannot prove that the product will reliably complete every real-world task. The candidates below should therefore be treated as the first systems to test, not as a pre-written ranking.
- CodexCodex combines a high-capability model with terminal access, files, skills, and connectors in one working environment. In supported desktop applications, once the relevant capability is enabled and system permissions are granted, it can also use a browser and Computer Use. This gives it a route from understanding and producing artifacts to operating real software. Its practical reliability still depends on network stability, permissions, execution-state visibility, long-task recovery, error detection, and the frequency of human takeover.
- Claude CodeClaude Code began around terminal, file, and software-engineering work, then expanded into browser and Computer Use capabilities. This places it among the small group of candidates with broad digital-employee potential, particularly for long-context reasoning, research, engineering, and cross-application work. Its Computer Use capability remains a research preview with platform and usage constraints. Stable access to accounts and network resources also matters in markets where those resources cannot be assumed.
OpenClaw and Hermes Agent: open foundations that still require construction
Open agent runtimes can provide the persistence, control, memory, and extensibility needed to build a digital employee. Their openness should not be confused with a guarantee that every deployment already possesses mature, general-purpose computer control.
- OpenClawOpenClaw provides an agent loop, tools, browser access, memory, goals, background tasks, messaging channels, nodes, and recovery mechanisms. It also offers node-based paths for computer control, making it a serious candidate for running persistent digital employees. Actual desktop capability varies by operating system, node design, Computer Use component, permissions, and deployment environment. In Claw-SWE-Bench, the same model achieved 19.1% Pass@1 through a minimal adapter and 73.4% through the complete OpenClaw adapter. That result demonstrates the importance of the runtime and task harness within this coding benchmark; it does not prove reliable completion of general business or desktop work.
- Hermes AgentNous Research’s Hermes Agent is an open, model-agnostic, self-hostable runtime with terminal, file, browser, memory, skills, scheduled tasks, and persistent goals. Desktop operation can be added through an external CUA Driver and system permissions, but it is not an inherent capability of every Hermes deployment. Hermes documentation also acknowledges that goal-completion judgments may produce false positives or false negatives. Tools, goals, and Computer Use are therefore infrastructure; real task completion still requires independent acceptance.
Domestic and comparative candidates must first prove their action boundary
Qwen Code’s official materials list Computer Use among its capabilities, so it should not be treated as a terminal-only candidate. Its terminal, file, MCP, and multi-model support also make it especially relevant to delivery in China.
An official capability statement is not proof that a system can already operate every desktop application reliably. Supported platforms, permission handling, cross-application continuity, error recovery, and real-task completion must still be tested independently.
WorkBuddy, Kimi Code, and OpenHands are also worth studying. They offer different strengths in domestic office access, terminal execution, open-model support, and self-hosted environments.
Before any of them is described as a complete digital-employee foundation, a more basic question must be answered: can it reliably operate the entire computer environment required by the target work, or is its action boundary still limited to content creation, a terminal, a repository, a browser, or a small set of integrated tools?
The ability to invoke MCP, run a command, or operate a webpage should never be treated as evidence that an agent can already perform the broad range of work a human can complete on a computer.
The best foundation must emerge from real work
Our current research suggests that Codex and Claude Code should be tested first as general computer-execution candidates. OpenClaw and Hermes Agent are open runtimes worth building and testing. Qwen Code deserves early validation of its Computer Use maturity in domestic delivery environments. Other products can serve as domestic, task-specific, or model-neutral comparisons, but their action boundaries must be established first.
There is not yet enough evidence to declare any one of these products the best digital-employee foundation across all business contexts.
The best foundation may be a finished agent product, a powerful model combined with an open runtime, or a different configuration for each market and category of work.
The best digital-employee foundation is the combination that can reach every action required by the target work and continue achieving real outcomes with low human takeover, low false completion, and an acceptable long-term cost.
How Liuma Lab will test the claim
Liuma Lab will not announce a winner first and then search for evidence that supports the conclusion.
We will build test tasks from real work and ask candidate systems to own a complete responsibility under explicit permissions and acceptance criteria.
For every test, we will record which actions the agent completes itself, where a person must take over, whether the intended outcome is achieved, whether the agent falsely reports completion, how it recovers from failure, and the true cost of closing the task.
An article, report, presentation, codebase, or website counts as the final result only when that artifact is itself the user’s intended outcome. Otherwise, it is an asset produced along the way.
General-purpose computer use allows an agent to move beyond pre-integrated tools and pursue end-to-end outcomes across much broader work. Whether it can repeatedly get the real job done determines whether it is qualified to be called a digital employee.
- ProcurementComplete a real purchase within a defined need and budget, through order placement, delivery tracking, and acceptance.
- Website deliveryTake a website from requirements to public availability and verify its core business functions.
- Customer serviceReceive a real inquiry, verify the necessary facts, resolve the issue, and return the result.
- Cross-application workComplete a business process that moves through multiple real desktop applications.
- Failure recoveryResume and finish after a network interruption, missing permission, restart, or tool failure.