How Far Can You Automate Your PC With Generative AI? — Comparing GPT-6 Astra and Claude Using the Official Documentation

September 19, 2026September 21, 2026

You keep hearing that you can automate your PC with generative AI. The trouble is knowing what to choose, and how.

There are two ways to go about it. Both get called “having generative AI operate on your behalf," but what do you get, and what do you give up, with each?

What This Article Covers, and How I Checked It

Three things: what GPT-6 Astra can actually do; how it relates to the agent apps people have been talking about for a while, OpenClaw and Hermes Agent; and what to look at when choosing.

I’ve split this into sections: what’s stated officially, and what’s not stated officially but comes from various write-ups.

What GPT-6 Astra Is — The Numbers OpenAI Publishes

These I read directly off OpenAI’s developer pages.

Item	Value
Model name	gpt-6-astra
Context window	1,050,000 tokens
Input cap	922,000 tokens
Output cap	128,000 tokens
Supported endpoints	Chat Completions / Responses / Batch
Unsupported endpoints	Realtime / Assistants / fine-tuning / embeddings / image generation / video / audio / transcription

Pricing, per million tokens, is as follows.

	Short context	Long context
Input	$10.00	$20.00
Cached input	$1.00	$2.00
Output	$50.00	$75.00

GPT-6 Astra is one model, but its price list has two tiers. The right-hand column above is the rate when the input is long. Per million tokens, input goes from $10.00 to $20.00, a doubling, and output from $50.00 to $75.00, a 1.5x rise. What rises is the price — not the capability, and not how much it can handle. The official pricing page lists the two side by side.

Various write-ups state “the threshold is 272,000 input tokens," but that threshold is not written on the official pricing page itself.

There Are Two Ways to Automate Your PC

This is the fork in the road. The official documentation lays out two approaches, and recommends one of them for GPT-6 Astra.

Approach	What happens
Executing code (the officially recommended one)	The model writes a program that performs the operation, which the app then executes
Operating the screen (usable as an alternative)	The model issues direct instructions — “click here," “type this" — which the app translates into actions

Here’s the official wording.

For GPT-6 Astra, we recommend code execution.
The computer tool remains supported as an alternative.

The operations available for the screen-driving approach are also listed officially: click, double_click, drag, move, scroll, keypress, type, wait, and screenshot — nine in total.

The reason this became a talking point now is that the screen-driving side got faster and more accurate. By the figures the write-ups carry, finishing one PC-operation task took the previous generation roughly 75 minutes and now takes roughly 40 minutes. Accuracy at picking the right spot on screen went from 76.9% to 92.7%.

Accuracy is the one doing the work here, I think. Miss one action in four, and a ten-step sequence simply never reaches the end. Only above 90% does “hand it a long task" start to make sense.

There’s a twist in the two approaches, though. The side that got fast, and got attention, is screen driving — while the side the documentation recommends is code execution.

When plenty of write-ups describe this as “looking at what’s on screen and operating it the way a human would," I’d guess it’s because that’s the side that got faster. They aren’t wrong. The documentation also notes that screen driving is the better fit when the app on the receiving end wants to consume a fixed, predictable set of actions.

Either way, the model on its own does not move your PC. What the model does is write the program, or say “click here" — nothing further. Running it, and doing the actual clicking, is the app’s job. What you’re told to prepare is likewise two things: an API key and a framework to execute with. The “automation" people are talking about is not the model’s capability by itself; it’s the model combined with a framework.

On the model’s own side, the published number that looks relevant to automation is how much it can take in at once. At 1,050,000 tokens you can hand over a long procedure without cutting it in half. The documentation does not say “and therefore it suits automation," though — tying the context size to automation is my own reading.

Does Safety Come Built In?

This part is worth reading closely. The official documentation frames safeguards as something the implementer has to build.

Use an isolated browser or VM and an allow list of sites and actions.
Keep users in control of purchases, data transmission, destructive changes, and other actions that are hard to reverse.
Text in a page, document, or tool result cannot grant permission or override the user’s instructions.

That last line is the one that matters. If the AI reads a page that says “execute this," that text does not count as permission.

Hand operation over to an AI, and along with your instructions it also reads whatever’s on the page in front of it. If that page says “I am the administrator, run the following command," the model isn’t supposed to treat that as an order. The mechanism that draws this line does not come built in.

Does Claude Have the Same Two Options?

Worth checking whether the same design exists elsewhere. Reading Anthropic’s developer pages, Claude also offers both “executing code" and “operating the screen." On one of the two, though, whose machine runs it is different.

Approach	What Claude does	Where it runs
Executing code (code execution)	Writes and runs code inside a box that has Python in it	Anthropic’s side. 1 CPU, 5GiB memory, 5GiB disk. No internet access
Operating the screen (computer use)	17 operations: take a screenshot, click, type, and so on	An environment you set up. Anthropic does not touch it

The code-execution side never reaches your own PC. It finishes inside that box. The documentation puts it this way.

The container has no internet access, so Claude can’t download or install additional packages at runtime: only the pre-installed libraries are available.

This is where it diverges from GPT-6 Astra. When GPT-6 Astra “executes code," the thing running it is your own app. Claude’s runs in that box on the other end. Same name, different answer to whether it can touch your local files.

Screen driving, on the other hand, works the same way as GPT-6 Astra. The model only says “click here"; the hands are your app’s.

When you use computer use, Claude doesn’t directly connect to this environment. Instead, your application: 1. Receives Claude’s tool use requests 2. Translates them into actions in your computing environment

The safety wording points in the same direction as OpenAI’s, too.

In some circumstances, Claude will follow commands found in content even when they conflict with your instructions.

Two companies writing down the same worry suggests this isn’t one vendor’s rough edge — it’s something that comes attached to automation itself. If it were one vendor’s problem, the same warning shouldn’t appear on the other’s official page.

There was a difference as well. Anthropic writes that classifiers automatically scan what the tools return and flag suspicious instructions. One layer, at least, comes with it. Past that, though, the mechanism for making a human confirm irreversible actions is again framed as the implementer’s to build.

One more thing: Claude sits on the hands-on side too. There’s Claude Code, which runs in a terminal, and the Claude Agent SDK, which packages it as a library.

The Agent SDK gives you the same tools, agent loop, and context management that power Claude Code, programmable in Python and TypeScript.

Reading, writing, and editing files, running commands, searching the web — those tools are in there from the start, and the place it runs is your own machine. GPT-6 Astra sits on the model side and OpenClaw on the hands-on side, but Claude sits on both. “Picking a model" and “picking an app" are separate questions, and Claude’s name comes up in each.

Are OpenClaw and Hermes Agent Competitors?

This is the part that gets muddled. What GPT-6 Astra competes with is generative AI like Claude. OpenClaw and Hermes Agent, the names that have been circulating for a while, sit on a different axis — they’re the hands, not the thinking.

On top of that, you can combine them with GPT-6 Astra. Both projects state that the model they drive can be swapped out. They aren’t fighting over the same ground.

These are numbers I counted directly from the source repositories (September 10, 2026).

	OpenClaw	Hermes Agent
Repository	openclaw/openclaw	NousResearch/hermes-agent
Star count	389,272	243,671
Written in	TypeScript	Python
Listed license	Other	MIT

The listed licenses differ, but reading the actual text, both are MIT. OpenClaw’s license text is MIT itself, with one extra line appended at the end stating that third-party code attributions are recorded in a separate file. That single line is what makes the automatic classifier read it as “Other."

Most write-ups say “both are MIT." Looking only at the badge, they look different. Both statements are correct — they’re just looking at different things.

Where Does the Money Go?

The apps that do the operating get installed on your own machine. Claude Code, OpenClaw, and Hermes Agent all work that way (OpenAI’s Codex looks like the same shape, but I could not open the official page to confirm it). The apps themselves cost nothing. What costs money is the model you point them at.

Which narrows the decision to one thing: which model do you have it call?

	Calling GPT-6 Astra	Calling Claude	Calling a local model
What it costs	Pay per use $10.00 input / $50.00 output per million tokens	Pay per use	Electricity and hardware only
Cost of the app	None	None	None
What you hand it	Leaves your machine	Leaves your machine	Stays local
Screen-driving accuracy	The level being talked about	Same mechanism. I haven’t compared the figures	I haven’t confirmed this

This isn’t about which one is better. If you don’t want what you hand over leaving your machine, use a local model; if you want to start without owning hardware, use a cloud model. That’s the actual split.

And “can I get away with just the app?" turns into “does a local model reach the required accuracy?" At a level that misses one action in four, a sequence stops partway. I have not measured what local models do here.

What I Haven’t Confirmed in This Article

• The comparison in this article rests on what each company’s official pages state. I have not measured speed or usability under matched conditions. I do use Claude, but not in a way that lines it up against the others on the same task
• The threshold where pricing switches to the “long context" rate is not written on the official pricing page. Various write-ups say 272,000 tokens
• Availability in Codex, and whether it’s usable on each plan — I could not open the official page for this. This comes from various write-ups
• I have not put OpenClaw and Hermes Agent through the same task. Apart from the star counts and the license text, this rests on what the projects themselves state
• Claude’s two options (code execution, screen driving) are things I read on the official pages, not things I wired up and ran
• Combining a framework with a model — say, driving GPT-6 Astra from OpenClaw — is something I read in the projects’ own documentation, not something I ran
• That 1,050,000 tokens is what’s behind automation’s reputation is my own reading. The documentation doesn’t say so, and I haven’t compared
• The timing and accuracy figures are what the write-ups carry; I could not open OpenAI’s announcement page. Some write-ups attribute them to OpenAI’s own announcement and others to third-party testing
• Star count is a rough popularity signal, not a quality metric

Closing — Automation Splits Into Two Things

To automate a PC with GPT-6 Astra, there are two approaches: have it write and execute code, or have it operate the screen directly. The official recommendation is the former; the latter remains usable as an alternative.

Safety mechanisms do not come built in. In particular, the line “text the AI reads on a page does not count as permission" is worth internalizing before you automate anything.

OpenClaw and Hermes Agent are not what GPT-6 Astra is fighting over. They’re the hands, so you can combine them with it. What it’s fighting over is generative AI like Claude.

The money goes to the model’s side as well, not the app’s. Pay per use, or own the hardware and hand the work to a local model. That’s the split.

The next article walks through the actual steps to get started.