Until now, there was a simple division of labour: the language model explains, the human clicks. With models that operate the computer themselves, this boundary shifts. A recent practical test by Golem.de describes GPT-6 Astra as a model that carries out tasks directly on the screen — mentioned are sorting the download folder, repairing a muted microphone and setting up a computer.

These are unspectacular examples, and that is precisely what makes them interesting. It is not about creative text work, but about those small-scale activities that arise daily in companies and are rarely documented.

What a computer agent does differently technically

A classic chat assistant returns text. A computer agent — that is, an AI system with access to mouse, keyboard and screen content — instead works in loops: look at the screen, determine the next step, execute the action, check the result. Instead of instructions, a chain of actual interventions in the operating system emerges.

The difference is fundamental. A wrong sentence in an answer costs reading time. A wrong click in the system settings or in the file system can change configurations and move data. Anyone who uses such agents thus moves from information gathering into execution — and accordingly needs different safety nets.

The task types in view

The three examples from the practical test represent different levels of difficulty, and this distinction helps with one's own assessment:

  • Sorting files is easily reversible and easy to check. The result is visible, errors can usually be corrected without damage.
  • Repairing a muted microphone is a diagnostic task. The cause can lie in the system settings, in an application or in the hardware — what counts here is whether the agent narrows it down systematically instead of guessing.
  • Setting up a computer is the most demanding category: many steps, many dependencies, and an error at the beginning affects everything that follows.

In practice, this means: the longer the chain and the harder an intermediate step is to verify, the more closely one should look before handing over responsibility.

Where automation takes hold in everyday life

Computer agents are interesting where no interface has existed so far. Many routine tasks in companies run through interfaces that were never intended for automation: legacy systems without an API, service providers' portals, desktop tools without script access. Classic automation regularly fails here due to the lack of a connection.

An agent that works at the screen like a human bypasses this problem. At the same time, this is its weakness: it depends on precisely that interface which can change with the next update. Where a stable interface exists, direct technical integration remains the more robust and more traceable solution.

Questions to clarify before use

Before such a tool lands in a company, a few sober preliminary considerations are worthwhile:

  1. What rights does the agent really need? A separate user account with tightly limited access is something different from execution in the administrator context on a workstation with access to business applications.
  2. What data does the model see? An agent that evaluates the screen potentially captures everything that is currently open — including open emails, customer data or password fields. This is a data protection question, not just a technical one.
  3. What is traceable? Without a log of the executed steps, it is hardly possible to reconstruct what happened in the event of an error.
  4. Where is the approval boundary? A clearly defined point at which a human confirms makes sense — for example before deleting, before system changes, before sending data externally.
  5. Is the effort worthwhile at all? For tasks that arise three times a year, manual completion is usually cheaper than maintaining an agent.

Realistic expectations instead of a fundamental debate

The practically relevant question is not whether such models can operate the computer — that is obviously the case. It is how reliably they do so and whether checking the result costs less time than the task itself. This is exactly where the benefit in everyday work is decided.

A sensible start is therefore tasks with three properties: they are reversible, their result can be checked in seconds, and they do not touch sensitive data. Clean-up work in file storage, recurring exports, the preparation of test environments. Anyone who gains experience there can gradually expand the scope — and notices early which task types are actually viable in their own environment.

In any case, it is striking that such tests say less about the model than about the processes. When an agent fails at a task, it is often because responsibilities, naming conventions or storage structures are unclear. This clarification is a gain even without AI.

What this means for web and software projects

For project practice, two points move to the fore: applications should offer stable, documented interfaces so that automation does not have to take place via the detour through the interface. And permission concepts need a role for non-human actors that is tightly scoped and logged.

Those who think about both early on can later deploy agents in a targeted way, instead of retrofitting them around an architecture that was never designed for them.

Sources