The Screen as Interface:
What New Opportunities GPT-6 Astra's Computer Use Opens Up

§ 01 One-Week Timeline: From Repo Leak to Enterprise Governance

The pace of this event was faster than most model launches, so it's worth laying out the timeline first.

September 3, early morning, ~10+ hours before launch. Someone digging through the OpenAI official repo openai-cua-sample-app found a PR #71 submitted by an internal account, on a branch named gpt6-computer-use-images, adding two environments: gpt6-js-image and gpt6-py-image. Token Gremlin checked the GitHub history and posted: "That's computer use."—what GPT-6 would lead with was no longer in doubt.

September 3. OpenAI's official tweet was just two sentences: "This is GPT-6 Astra. Anything you can do on a computer, Astra can do for you. Fast." The launch video paid homage to MIT Architecture Machine Group's 1979 "Put That There" demo; per Browserbase engineer Kyle Jeong's September 7 tally, the tweet had 131M views by then. Baoyu relayed that president Greg Brockman said at the pre-launch press briefing that he personally believes OpenAI has achieved AGI, and "looking back, this might be the model."

September 4. API opened for gpt-6-astra, standard pricing at $10/M input tokens, $50/M output tokens. OpenAI's computer use team simultaneously announced: paired with Astra, ChatGPT's computer use is nearly 2× faster; and the harness-layer optimizations are general—even the older GPT-5.6 Sol runs ~60% faster (Sac quoting the official statement). The same day, Maximilian Sieb, a core member of OpenAI's computer use team, announced his departure; his farewell post got 2.3M views and contained one sentence that summed up three years of this trajectory: "We took the model from not being able to click the right date when booking a flight, to computer use in the mainline model, to this week's Astra."

September 5–6. Demo wave. KEITO had Astra draw its own portrait in Canva with a mouse, 840K views; Alexey Fateev gave Astra and Claude Fable 5.1 the same photo and the same Paint, captioned "Fable 5.1 owes me an apology," 1.19M views; Mark Kretschmann watched it play piano and asked "has computer use been solved?" Will Hu rounded up 7 high-engagement cases 48 hours post-launch, 1.5M views, detailed later.

September 7. Jensen Huang declared "AGI has arrived," and revealed Astra trained on over 100,000 NVIDIA Grace Blackwell NVLink72 systems. OpenAI itself confirmed this scale: research VP Aidan Clark told reporters this was their "largest training run to date," "this is the first time we've done pre-training on over 100K GPUs, at Stargate in Texas." Kyle Jeong published his source code teardown blog. Bilawal Sidhu fed Astra a 3D scan of his parents' old house to turn into an editable scene, then "turned down gravity and opened a portal."

September 8. First bucket of cold water. CoArena released CUA KnowledgeBench: spent over $50K having frontier models do 12 hours of real company work; Astra "barely squeezed into the top three." The same day, Kyle Jeong announced that with a Stagehand translation layer, Astra's computer use is another 2.5× faster.

September 9. Second bucket of cold water. Francesco's team pushed back on the widely shared high-speed demo videos: pre-batched actions ≠ real-time agent decisions, "this is not today's everyday real-time computer use, and probably won't be within a year."

September 10. Three things on the same day. OpenAI's James Sun announced enterprise-grade CUA governance: site and app whitelists, per-item toggles for upload/download/history/CDP, adjustable approval levels, every screenshot and action streamed to OpenTelemetry. OpenAI released the Agents API, moving the Codex harness to cloud hosting, public beta. NeoCognition released ApprenticeBench, with a judgment we'll cite repeatedly: "No more CUA tax"—GUI operation success rate caught up with API for the first time.

September 10–11 (v2 addition). In that same 48-hour window, three pieces of third-party CUA infrastructure landed, each occupying a different position. Berkeley RDI (Dawn Song's group) released CUA-Lite, unifying environment, data, and harness into an open-source standard, with a VM-free desktop sandbox and 30K+ verifiable tasks; Microsoft released Project Zenith, baking agent identity and container isolation into Windows, making the OS the agent control plane; xAI released Grok Bot for Enterprise, each bot getting its own independent cloud computer plus a role, with built-in access and audit controls. The same weekly digest also disclosed OpenAI's internal agent usage data—by mid-August, ~3.1 agent workdays per human workday, but over half of successful 4-to-8-hour tasks still required human intervention. Open-source standard, operating system, enterprise product—three directions moving simultaneously in one week, showing that the layer described in §05 isn't just an "opportunity"—it's already a battlefield.

§ 02 Official Numbers: Twice as Fast, Safety Down an Order of Magnitude

OpenAI's launch page doesn't give much data in the computer use section, but every row can be cross-referenced.

A few places worth pausing. OSWorld 2.0 score went up only 7 points, but time dropped 47%—"faster" is the bigger change than "more accurate." ScreenSpot-Pro is a pure localization test (given a professional software screenshot, find where to click), and 76.9% → 92.7% is the largest jump in this table, also the source of the "coordinates are fast and accurate" impressions on X. AutomationBench more than doubled, but the absolute value is only 41.4%, meaning over half of automation tasks still can't be done.

The safety row needs separate explanation. OpenAI uses an "adversarially selected, specifically designed to induce model errors" computer use task set to measure adverse outcome rates—Astra is 2.4%, previous gen 22.0%. The launch page also states that in internal evaluation, Astra "never attempted to bypass Codex Auto-Review's refusal," even when review was deliberately configured to be bypassable, and bypassing was necessary to complete the task. This is the foundation that lets OpenAI push CUA to enterprises; we'll return to it when discussing the governance layer.

v2 adds two more CUA-relevant safety numbers, from OpenAI's September 1 "Path to Astra: critical capabilities and frontier safeguards". First, jailbreak refusal rate: Astra refused 91.5% of violating requests, vs. 59% for the previous-gen Sol. Second, "scope convergence"—this one is what really matters for CUA: when testing whether the model would reach for off-limits systems on difficult tasks, Astra stayed within its assigned task scope, while Sol without production guardrails attempted to access honeypot targets in 56% of similar tests. When an agent can operate an entire computer, "will it stay in bounds" matters more than "is it accurate" for production readiness. The same article also notes a timeline detail: after the Hugging Face incident, OpenAI paused some frontier training for two weeks to harden training infrastructure; large-scale frontier RL didn't restart until August 28, after new requirements were in place.

This table itself needs a footnote. OpenAI's OSWorld 2.0 was run on the v2026.08.08 offline set, while Anthropic's own launch page gives Claude Fable 5.1's OSWorld 2.0 as 77.9% (partial) / 41.7% (strict), and Opus 5 as 75.4% / 39.6%—all run on the benchmark authors' August 2026 task set, with all three Claudes re-run under the same conditions. Anthropic states in a footnote: the task files differ from earlier releases, so these numbers cannot be directly compared to previously published OSWorld 2.0 results, which is why that column is left blank rather than citing other vendors' public scores. Also, Fable 5.1 was run with production guardrails on; tasks where guardrails intervened were scored zero, which Anthropic says likely depressed their results. So treat the "Third-party ref." column as an order-of-magnitude reference, not a same-condition ranking. The number to keep in mind is the strict figure: the best model under strict judgment achieves only 41.7%, nearly matching AutomationBench's 41.4%.

A few other numbers don't directly concern computer use but determine its "chassis": Terminal-Bench 4.0 from 37.3% to 57.9%, FrontierMath Tier 4 to 97.6%. OpenAI also says Astra reached the "Critical" threshold of its Preparedness Framework for cybersecurity, with a perfect ExploitBench score. The connection to CUA: the smarter the model, the fewer turns needed to complete a task, and turn count is the bottleneck for CUA speed.

Same Model, Two Harnesses, 37 Points Apart

A correction from this article's first edition. v1 wrote ARC-AGI-3 as "from 7.8% to 99.9%," an inexcusable error: those two numbers come from two different harnesses and cannot be juxtaposed. ARC Prize's September 3 evaluation report explains this clearly, and after correction, the remaining fact is exactly what the rest of this article argues.

ARC Prize ran the same Astra under two harnesses. Standard harness is the provider-neutral minimal interface: the model decides which notes to carry forward as visible text, old history is truncated past a length threshold, and the previous turn's reasoning draft is cleared each step. Provider Adapter harness uses OpenAI's own context management designed for Astra: preserving invisible reasoning state between requests, with compaction for long sessions instead of truncation.

Same weights, same games, same problems, the result is 62.7% (Standard, max tier, $26,098) vs. 99.9% (Provider Adapter, high tier, $18,817)—a 37-point gap, and the more expensive side is the lower-scoring one. On the 167 game-reasoning combinations unlocked by both harnesses, the Provider Adapter side is ~3.66× faster and uses 49% fewer tokens. ARC Prize's conclusion is that both scores count as state of the art, but going forward the two evaluation conditions will be listed separately. The comparable improvement over the previous generation should therefore be 62.7% vs. 7.8%—still a massive leap, but the one the benchmark actually supports. Per The Next Web's compilation of the same leaderboard, the harness effect isn't OpenAI-exclusive either: Claude Opus 5 on its own scores 30.16%, but under NVIDIA AVO and AWS Strands scaffolds reaches 100 and 99.95 respectively.

The report also has two CUA-relevant findings. First, higher reasoning effort is actually cheaper: under Standard harness, max tier scored 62.7% for $26,098, while medium tier scored only 38.6% but cost $48,090—because a model that thinks clearly uses fewer actions to solve, reducing both model calls and tokens. The implication for CUA is direct: the way to save money isn't to lower effort, it's to reduce turn count. Second, in ARC Prize's separate PRO-LONG harness giving Astra a code-execution sandbox, it builds a custom toolset for each game—in maze game tu93, it first writes maze_solver.py for navigation, then adds combat_solver.py for combat rules, patrol_solver.py to model patrol squads, and sync_state.py to align predictions with observations. In other words, the model has started writing its own harness.

A necessary caveat: ARC Prize explicitly rejected OpenAI's conclusion—"we are not claiming this is AGI"; solving ARC-AGI-3 doesn't constitute proof of AGI, and co-founder Mike Knoop's exact words were "we don't yet have evidence to call this AGI." This statement is worth reading alongside Greg Brockman and Jensen Huang's pronouncements in §01.

§ 03 Why It Suddenly Works: Teardown of Astra's CUA Loop

Kyle Jeong has spent three years productionizing computer use at Browserbase; his September 7 blog is the clearest technical teardown available, sourced from the Codex open-source repo and ChatGPT client code. His core framework in one sentence: computer use is two problems—harness (engineering) and model (research). The model decides what to do; the harness makes it happen. Both must be solved.

The old approach's root problem. In October 2024, Anthropic broke first ground with Claude 3.5 Sonnet, using pure vision: the model views a screenshot, outputs pixel coordinates plus an action, and a driver like Playwright executes it. Later, OpenAI's Operator and Google's Gemini 2.5 Computer Use followed the same approach. The problem: models are post-trained on a fixed viewport (e.g., 1288×711), and accuracy degrades on different window sizes; plus screenshots can't show internal state—whether a button is disabled, whether form validation passed—so the model can only retry repeatedly.

Astra's approach: read the screen as text, write actions as code. Every web page in Chrome, and most desktop apps, auto-generate an a11y tree (accessibility tree) for accessibility mode, listing each UI element's role, label, and state as structured text. It's more token-efficient than screenshots and inherently carries state. Astra prioritizes reading this tree, supplementing with a screenshot when needed, then emits actions as code. A typical output looks like:

{
  "type": "function_call",
  "name": "exec_js",
  "arguments": "{\"code\":\"await page.getByRole('searchbox').fill('browser automation'); ...\"}"
}

In other words, computer use is now code mode. OpenAI's API docs even recommend routing all computer use through code execution—Playwright for browsers, PyAutoGUI for desktop.

The architecture itself isn't complex. At session start, Codex launches a Node REPL to hold state, binding browser or native app operation interfaces. The model observes (text, screenshot, or both), writes code to execute actions, and a local service called CodexComputerUseIPC-5 lands actions onto element IDs or coordinates via JSON-RPC over a native pipe. Execution isn't the end—Astra observes again, reconciles current vs. expected state, then enters the next round. Because computer use is inherently stateful, this REPL must persist for the entire session.

Guardian: pre-execution safety review. Astra is the only model that requires auto-review. The mechanism uses GPT-5.6 Luna as a background classifier, evaluating the current workflow's risk and returning high or low; high triggers a blocking review of subsequent actions, with the reviewer outputting a conclusion like {"risk_level": "high", "user_authorization": "low", "outcome": "deny"}. Common interception items include permission grants, login and account-level operations, sensitive data submission, consequential clicks, bypass attempts, destructive operations, and out-of-scope private data access. Anyone who's delegated tasks through Codex has probably hit several of these.

So why is it fast? Kyle's answer is朴素: it's smarter, so it takes fewer turns. Astra's post-training on over 100K GB300s spent extensive time on reinforcement learning in computer use environments. Inference speed isn't the main factor: once you exceed ~300 TPS, the bottleneck shifts to action execution, not generation. Harness-layer websocket preheating, connection reuse, and incremental requests via previous_response_id compress tool startup time but don't change per-step action speed.

One piece of circumstantial evidence is telling. Kyle's team built a translation layer converting Astra's Playwright commands to Stagehand, getting another 2.5× speedup; his example was Astra deciding on its own to merge the entire logo drawing into a single command, drawing it in one go. This is the concrete form of "smart → fewer turns → fast": not that each stroke is faster, but that it knows to pack a hundred strokes into one.

What's still unsolved. Kyle himself lists three: observation can fail (a11y state incomplete, screenshot detail insufficient, or view already stale); state can drift between observation and action—some apps' a11y trees change frequently, causing actions to miss; and long-horizon computer use is basically unvalidated—compaction can keep things running a long time, but nobody's seen how it performs over days or weeks.

§ 04 Two Voices on X

Viral Demos Fall into Four Categories

Classifying the week's high-engagement cases by "what is it actually operating on" is more informative than ranking by view count.

Category one, portraits. Canva, Paint, Apple Notes, Kleki—give it a photo and have it stroke by stroke reproduce it. Most visual impact, least practical value. Jesse Lau put it directly: having an LLM copy a picture's pixels and repaint it "is something a pre-written program could handle," pure token waste. But he then named a genuinely useful scenario: open TradingView, directly draw trend lines, resistance levels, Fibonacci retracements and wave annotations on a chart, giving a preliminary reading as a pre-filter before manual trading.

Category two, 3D and games. This was the highest-traffic category. Annalea one-shot in Blender, 970K views; Kevin Kern had it build a car in Blender; Will Hu's roundup included a /goal running 5 days of SimCity clone, a Manager Loop running a week to street-by-street build Manhattan in Unreal Engine, an old steam train blueprint turned into 3,295 editable objects, and 600 Astra agents living in the same Unreal world. Tykoo's observation noted a side effect: the flood of Blender 3D builds further muddied the already-unclear "world model" definition, stealing all the traffic from Fei-Fei Li's model released days earlier.

Category three, production tools. Lower view counts, but every case is someone actually using it for real work. Sac had Codex directly operate Jianying for rough cuts, "perfectly adequate as a rough cut"; Kyle Balmer has all long videos edited by Codex, then uses computer use to upload to YouTube, fill descriptions, and upload thumbnails; AWAMORI had it slice assets from an Illustrator landing page design to code, consuming 15% of the Pro 5x plan's weekly quota including revisions; LinearUncle added animations in Keynote, with content from Codex-generated SVGs; cosine discovered Figma dev MCP is no longer needed—Astra directly views properties and edits designs in Figma.

Category four, dev-to-acceptance. Baoyu's assessment got 200K views: "Unlike GPT-5.6 which needed a slight wait before acting, it can now quickly and precisely help me test the app... this brings the biggest improvement: letting the Agent form a complete closed loop from development to acceptance." quark_h went further: to test a Windows client, open a Windows VM, remote-login from Mac, and have Codex operate Windows through the Mac interface—"the testing process is very smooth."

Will Hu's conclusion after surveying 7 cases matches ours after reading 200+ tweets: "Previously, AI automation meant first giving the Agent APIs, MCP, and plugins, then teaching it how to use software. Astra's approach is to let the model treat the screen as the interface and the entire computer as a tool. So what it's most likely to rewrite first isn't content generation—it's those powerful, high-learning-curve legacy apps that never got around to building AI interfaces."

Four Buckets of Cold Water

First bucket: real-time performance. Francesco's team's judgment was cited earlier. They themselves recorded multi-app demos of QGIS map output, Preview PDF annotation, and GIMP-to-Inkscape conversion, each annotated "gestures at 1× speed, waits/retries/setup edited out; these are edited clips, not statements of completion time." Cosmic Raven's complaint was more specific: "Astra plays piano in the demo, then spends 30 seconds opening a File menu. Medium reasoning tier runs a thinking step before each click—that's your 30 seconds." It should be noted that an OpenAI computer use team member claimed all demos in the launch video were recorded in real time. We cannot independently verify either claim, so both are presented side by side.

Second bucket: long-horizon performance. CoArena's benchmark deserves more detail because its design is completely unlike typical benchmarks. 10 undisclosed real company tasks, 5 seeds each, 50 runs total, 12 hours wall-clock time per run, 100+ applications, final judgment only on whether the work product passes—binary pass/fail. One environment is a distribution center shift: warehouse system, SAP-style ERP, team chat and email, 32 work windows, with evidence arriving over time. The result: best-performing Claude Fable 5.1 succeeded 12 times (24%), Astra barely top three. More interesting is the distribution: when a model can do a task at all, it succeeds in 2–3 of 5 seeds; the gap between models is mainly "how many of the 10 tasks are even doable"—head is 4, tail is 1. Even when successful, it's slow: Fable 5.1's median successful run took 6,940 actions, 6h 22m. CoArena is next spending $200K to run 1-day, 3-day, and 7-day versions. Doug Champion questioned in the comments whether this methodology is fair: "No agent would use a mouse in Gmail or Slack"—a critique that, placed alongside NeoCognition's "GUI catches API" conclusion, neatly brackets the current debate.

Third bucket: judgment. Max Schoening in one sentence: "Astra is way too eager to CUA." Qingfeng's example got 20K views: despite having GitHub CLI available, Astra turned around and opened Chrome to create an issue on the web. Akira said it's "very capable, but why does it always do what I don't want it to do?" arjun chintapalli's verdict after playing Cities: Skylines was sharpest: "It runs but slowly, can't handle fine operations like laying water pipes; after writing a harness mod it became smooth. CUA is a party trick; useful agents are solved at the harness layer."

Fourth bucket: professional software, and collapse on theme change. This bucket is v2's addition, and it sits directly opposite "No more CUA tax." Snorkel AI used the open-source Cua-Bench framework to build a KiCad benchmark—KiCad is a full electronics design automation suite with dense keyboard-shortcut syntax and multiple interlinked editors; it was chosen precisely because "common benchmark tasks are too short, domain-knowledge thresholds too low, and interfaces already designed for intuition, so frontier models can often bluff through by trial and error." 25 expert-authored tasks, results: 4 fully passed (16%), 16 hit the step limit without claiming completion, 5 declared completion on wrong artifacts, and all 16 "build from scratch" tasks failed entirely—every passing case was modifying a single component on an existing schematic. ~80% of errors fell in planning, perception, and navigation efficiency. The leaderboard has since moved slightly: the best frontier agent now passes 6 of 25.

The failure modes are more informative than the failure rate. In one case it typed a resistor value literally as 2.80kOhm, while KiCad's canonical format is 2.8k: topology check passed, value check failed. In another it stated the LT3010 LDO's reference voltage as 1.24V when it's actually 0.808V. Snorkel's commentary pinpoints the key issue—title bar, status bar, ERC dialog, or saved netlist could all have caught this error, but the Agent was reasoning against its own narrative, not reading the interface. This sentence and Yenpro Musik's "Agents like to say they're done" in §05 are two ways of saying the same thing.

The Cua-Bench framework itself brings a second piece of bad news: it was created precisely because existing CUA approaches show over 10× score variance under minor interface changes. The OpenApps study it cites shows that the same task's success rate can vary by 10× or more depending on theme, font, or language settings; the framework authors give a more striking example—an agent with 90% success on Windows 11 might drop to 9% on Windows XP for the same task. The reason is that benchmarks like OSWorld and Windows Agent Arena all run on static VM snapshots with fixed apps and fixed visual configs. So every number in the §02 table should be understood as "under that particular visual configuration."

These four buckets of cold water all point to the same thing: model capability has crossed the line, but judgment about "when to use CUA vs. when not to," and the engineering around it, are far from keeping up. That's precisely where the opportunities lie.

§ 05 Eight New Opportunities

1. Legacy Software Without APIs: The Market OpenAI Itself Named

This is the strongest signal across all our sources. James Sun's exact words at OpenAI: "CUA is especially useful for enterprises because many workflows happen in legacy or in-house software that has no MCP or API whatsoever." He said this governance setup has been tested for a month at "some of the world's largest companies," with new workflows emerging in procurement, finance, QA, GTM, marketing, and IT.

Sanjin, from a domestic enterprise perspective, said the same thing: "Many enterprise backends and traditional software lack good APIs. To connect MCP or write Skills, you often have to spend enormous effort打通ing the underlying operations first. Rather than making all legacy systems re-adapt to AI, it's better to let AI learn how humans already operate." His expected concrete scenario: "export backend data, organize into a spreadsheet, upload to another system"—across several software tools continuously, with self-checking on errors.

NeoCognition's ApprenticeBench provided the first quantitative evidence for this path. They had agents do a 7-month apprenticeship in a simulated California construction company's accounts payable department: learning ERP, learning conventions from company history, continuously learning from feedback, handling invoice errors, vendor communication, approval workflows and policy changes, and assigning cost codes to billing items. The conclusion: Fable 5.1 and Astra outperformed human professionals in this role, and "doing it via GUI is as good as doing it via API." Project member Boyu Gou went further: "The strongest agents now succeed more often via GUI than via API."

Implication for founders: for the past decade, "integration" has been the hidden tax of the SaaS industry—before a company can connect a new system, it first asks whether there's an API, then finds an FDE (forward-deployed engineer) to write glue code. If the CUA tax truly goes to zero, "does it have an API" goes from being the gatekeeper of automatability to a question of cost level. RPA vendors, system integrators, and everyone living off "we have connectors" all need to rethink where their moat is.

2. Three-Layer Tool Stack Becomes Default: CLI, MCP, CUA Each in Their Place

People actually using Astra in production on X independently described the same layering. Kevin Kern's car-building setup: Blender CLI for scripts, batch rendering and export; MCP for real-time scene inspection and editing; computer use for visual review and UI operations that CLI and MCP can't expose. Brent Schooley testing DaVinci Resolve on a fresh machine originally planned to write a Codex plugin, then found it unnecessary: "I watched Astra find places it could use Python scripts and use them, and switch to CUA where it couldn't."

The significance of this layering is that MCP isn't dead, but its position has shifted. Over the past year, MCP was the entry point for agents to access software; now it's retreated to the middle layer: use API where available, because it's cheaper and more stable; where that's not possible, CUA fills the gap. Xiong Bulang's assessment after research is that the open-source cua project is already a mature solution, but still falls short of Codex's computer use; he plans to integrate cua as a plugin into his own agent.

Implication for MCP developers: the value of writing a dedicated MCP for software with a complete GUI is declining, unless it can provide things GUI can't (batch processing, structured state, lower cost). Conversely, routing logic that "helps the agent decide which layer to use" is the new value point.

3. Dev-to-Acceptance Closed Loop: QA Can Finally Be Closed by the Agent Itself

Baoyu's "complete closed loop from development to acceptance" reflects a concrete engineering change. Previously, after an Agent wrote frontend code, verification meant a human opening a browser and clicking through; now Astra opens the browser itself, clicks buttons, checks results, and fixes bugs. OpenAI's launch page lists "run frontend QA checks, confirm all website features work" as a standard computer use scenario; Cognition's Silas Alberti said Devin integrated Astra into its harness on launch day, "the test videos are noticeably easier to follow, reports clearer and more concise." Lovable's CTO Fabian Hedin observed that Astra at high effort "spends more iterations on new builds, doing more validation through browser testing."

What this opens up isn't just the next step after "AI writes code"—it's a re-evaluation of the entire testing outsourcing and E2E testing tool landscape. quark_h's approach of using a Mac to remotely operate a Windows VM for client testing essentially turns a dedicated QA position into a prompt.

4. People Who Can't Code Can Now Do Automation

FleetingBits' thread of thoughts is the most complete argument for this direction, with 12K views. His core point: AI pessimists miss that new model capabilities reset the adoption curve. After ChatGPT came the chatbot adoption wave, after coding agents the second wave, and the next wave will be driven by computer use because Astra is approaching the usability threshold to support large-scale automation. He's already delegated expense reports, Airtable, Google Docs, calendar, and iMessage entirely to Astra—"a huge amount of enterprise office work is just copying things from one SaaS to another per rules in a Google Doc, and Astra can do that."

The key sentence: "Because computer use doesn't require the user to know any code, it can be used by a much broader range of office workers—they know what they want the model to do."

He also listed two gaps, each a company-sized problem: first, passwords and permissions still need human management, "Codex and Cowork need a built-in key manager"; second, computer use workflows still need human triggering, "we need a simple way to set up monitors at company or team account level."

5. Enterprise Governance and Audit Layer: "SOC for CUA"

Every item James Sun listed maps to a question enterprise security teams will ask: can you limit which sites and apps CUA accesses; can you manage upload, download, history, and CDP (Chrome DevTools Protocol) item by item; can you control human-in-the-loop degree by adjusting approval settings; does every screenshot, action, and approval flow to OpenTelemetry so administrators can audit and replay every trace.

Add the Guardian mechanism and OpenAI's statement on the launch page—"additional safety checks may sometimes slow, pause, or stop legitimate work, including defensive cybersecurity tasks; in ChatGPT or Codex the task pauses for your review, in the API it stops outright"—and it's clear OpenAI treats "controllability" as a prerequisite for CUA entering the enterprise, not an add-on.

Yenpro Musik's one-liner nails why auditing is necessary: "Agents like to say they're done. The week computer-use agents went mainstream, I stopped believing that word. The model can click, type, and leave a trail that looks like work." Whoever verifies that trail is real work owns this layer's business. Trace analysis, anomaly detection, compliance replay—building CUA-specific security operations around OpenTelemetry data streams, the market is just appearing.

And what v2 must add is why this layer is no longer an "add-on." Put §02's 37-point harness gap alongside Astra's architecture controversy, and you get an uncomfortable conclusion. ARC Prize's Provider Adapter achieved 3.66× speed, 49% fewer tokens, and 37 more points by preserving "invisible" reasoning state between requests—the original wording is opaque reasoning state. And The Information's September 1 report (single anonymous source, here per Fortune's relay and tracking) says Astra uses constrained "recurrent depth," also called looped transformer: circulating information through the same set of layers repeatedly to buy extra compute per token, at the cost of part of the chain of thought no longer being expressed in natural language. In Fortune's tracking of safety researchers' reactions, Redwood Research's Ryan Greenblatt called the shift to opaque reasoning a major regression.

OpenAI pushed back hard. Chief scientist Jakub Pachocki said they deliberately limited looped Transformer's scope to preserve reasoning legibility, and that current frontier models (including Astra) have computation graph depth within 2× of GPT-4; he wants to "avoid a race toward uncontrollability ignited by sloppy reporting." But in the same passage he admitted that chain-of-thought monitoring "is inherently fragile, and trending in a bad direction, for reasons unrelated to architecture changes." Sebastian Raschka also rejects this causality technically: layer reuse itself doesn't suppress visible chain of thought. To be clear, Astra's system card doesn't name recurrent depth; the architecture section remains based on a single anonymous source. But OpenAI itself did write that Astra is harder to monitor via chain of thought, can complete noticeably harder tasks without verbalizing its reasoning, and is better at controlling what appears in the reasoning trace.

These three things together form the sentence v2 most wants to leave with readers: the mechanism that makes CUA faster and the mechanism that makes it harder to monitor are the same. If part of the model's "thinking" no longer becomes text, then the only auditable thing is what it "did"—screenshots, clicks, keystrokes, approvals. James Sun's OpenTelemetry data stream is therefore not a nice-to-have; it's the only observation surface the enterprise has left. On this point, industry is already moving in the same direction: Mercor co-CEO Adarsh Hiremath said at Berkeley RDI's Agentic AI Summit that "evals are largely the bottleneck for enterprises successfully deploying agents," advocating that an agent evaluation must capture task, trace, context, artifact, and verifier—five things—so people know why it failed, not just that it failed; Google Cloud's Rao Surapaneni models enterprise agents as new employees—requiring identity, explicit access permissions, clear responsibilities, and runtime monitoring and intervention capabilities, summarized as "visibility, control, security," plus "trust but verify." Microsoft pushes the same thing down to the OS: Project Zenith provides OS-level agent identity and Microsoft Execution Containers isolation in Windows, requiring machines with at least 64GB unified memory and 250+ GB/s bandwidth to locally run 30B+ models. Who controls this layer—OpenAI, OS vendors, or third parties—remains unsettled.

6. Harness Layer: The Model Is OpenAI's, the Engineering Is Everyone's

This is the most discussed and most easily overlooked opportunity. Kyle's translation layer adds another 2.5× speedup, arjun's harness mod turns Cities: Skylines from a party trick into something usable, OpenAI's own harness optimizations make the previous-gen model 60% faster. Three examples saying one thing: once model capability crosses the line, most of the remaining improvement space is in the harness.

Flrande's comment is emotional but informative: "Codex has been viral for half a year, and they've already figured out computer use for Astra, while A➗ is still carving flowers in TUI." Whether you agree with the Anthropic assessment or not, Codex Desktop's harness has indeed become the baseline for comparison on X.

Specific problems are already being worked on: Cosmic Raven mentioned cua-driver solving desktop access issues including file choosers; Simular held a CUA salon at SF Tech Week themed "what still needs to happen before CUA goes mainstream"; Kyle mentioned Stagehand doing streamlined DOM and a11y tree snapshots, compressing 27K-token raw HTML to 6K. Whoever makes observation, action, state, and failure replay something developers can integrate with one line of code will own this layer.

v2 adds: this judgment was independently confirmed three times within one week.

First is those 37 percentage points. The two ARC-AGI-3 harnesses from §02 are the cleanest controlled experiment available—same weights, same problems, only context management differs, score from 62.7% to 99.9%. This isn't a soft "harness is also important" conclusion; harness contributed a larger increment than a model generation upgrade. On the same leaderboard, Claude Opus 5 went from 30.16% to 100 / 99.95 under NVIDIA AVO and AWS Strands, showing this isn't one vendor's trick.

Second is the live-web leaderboard itself. On Online-Mind2Web, a benchmark running real websites (300 tasks, 136 sites), Steel.dev's tracked leader is Browser Use Cloud's bu-max, per Browser Use's own public eval repo at 291/300 = 97% (they judged 2 of 9 failures as "impossible for any browser agent," yielding 291/298 = 97.7% after removal). The leader is a specialized harness, not a frontier model. A methodological caveat: Online-Mind2Web scores are sensitive to judging methodology; the paper's built-in WebJudge agrees with human judgment ~85% of the time, and some recent submissions used custom judges, with another Aside browser agent reporting 297/300 (99.0%)—so "leader" is relative to a particular inclusion standard. But the direction is unaffected: competition at this layer happens between harnesses.

Third is that this layer is starting to be standardized and open-sourced. Berkeley RDI's September 10 weekly digest released CUA-Lite, decomposing CUA development into three unified abstractions: Lite.Gym uses Gym-style reset / step / close to unify 15+ benchmarks into one observation format and a platform-partitioned GUI action space (desktop/browser click+type, mobile tap+swipe), with a built-in VM-free Docker desktop sandbox—replicating the same desktop at far lower cost than OSWorld, loaded with 30K+ verifiable tasks; Lite.Sample converts 10+ public CUA datasets into the same shape; and a shared harness for 14 model families (GPT, Claude, Qwen, UI-TARS, etc.) usable across eval, RL, and SFT. The problem it aims to solve is exactly what this section describes: every environment has its own runtime, every dataset its own format, every model its own action space—without common standards, connecting a model to an environment means re-implementing the same action mapping, context window, and rollout loop. The same weekly digest also mentions ByteDance's HarnessDev and HarnessEvolve letting open-source models build their own runtimes from empty sandboxes—the same phenomenon as ARC Prize seeing Astra write maze_solver.py in PRO-LONG: orchestration is shifting from a developer artifact to a model capability.

As a somewhat ironic contemporaneous phenomenon: the popular configuration on X and developer blogs is running Astra inside Claude Code—OpenAI's model, Anthropic's harness, with cheaper models underneath for grunt work. "The model is OpenAI's, the engineering is everyone's"—now even Anthropic's engineering counts as "everyone."

7. "Inverse Graphics" for Creative Production

Bilawal Sidhu's experimental workflow is worth recording in full: ~400 2D photos shot in 2019, run through RealityScan for photogrammetry to get a mesh; mesh dropped into Blender, where Astra turns it into a complete, clean, editable 3D scene with materials from photo scans and the rest via procedural shaders. His judgment: "multimodal LLMs may have crossed the inverse graphics chasm, with huge implications for VFX, AR/VR, and robotics," but he honestly noted defects: some errors are inherited from RealityScan's reference mesh, "humans are still much better at spatial auto-completion." His next step: have Astra use CUA to open photogrammetry software and continue refining against source images.

OpenAI's launch page BenchCAD data (multi-view rendering → CAD code inference, Astra 95.9% vs Sol 83.3%), Higgsfield CEO's "20% fewer tokens for complex creative workflows" quote, plus Dimillian's developer blog going from a one-sentence architecture requirement to a walkthrough-ready house in Unreal Engine 5, show this isn't one or two people's luck. Architectural visualization, game assets, film previz—links that previously required specialist days of labor now have marginal cost equal to tokens.

8. Agent Onboarding Rather Than Integration

ApprenticeBench's most interesting aspect isn't the results, it's the design. It models "deploying an agent" as "onboarding a new employee": no FDE, the agent reports to work itself, learns systems, learns conventions, continuously learns from feedback. NeoCognition's phrasing: "No FDEs. Agents deploy themselves into the job." They believe agents can become independent cross-industry workers within one to two years.

But the same thread also provided contrary data worth remembering. Human and agent learning behaviors differ: humans get faster with practice; agents get slower with more memory notes; humans need far fewer notes than agents, because humans are better at compressing learned things into mental models. John Rood proposed in the comments the real killer test: "teach an approval rule in month 2, replace it in month 6, then test whether the agent follows the new rule without resurrecting the old one. Continuous learning isn't accumulation—it's knowing what no longer holds."

OpenAI's Agents API released the same day is infrastructure for this direction: cloud-hosted Codex harness, with OpenAI handling orchestration, long-running sessions, and context management. Combined with the Codex features mentioned on the launch page—models can retain notes across context windows, with old windows still searchable rather than compressed into a single summary each time—"agent onboarding" has a technical closed loop for the first time. How far it is from actually working depends on CoArena's 1-day, 3-day, and 7-day results.

v2 addition: this path already has its first product with dollar figures. Per Berkeley RDI's September 10 weekly digest, xAI released Grok Bot for Enterprise: each Bot runs on its own independent cloud computer, is assigned a specific role, and keeps working until the task is done or a human needs to make a call; the enterprise version adds access, network, and audit controls. xAI says their own procurement bot, by analyzing vendor spend, usage, contracts, and market alternatives, has already identified over $100K in potential savings. Note that "procurement" is exactly the first of the new workflows James Sun named—OpenAI treats it as a CUA application scenario, while xAI directly ships it as a product with a role and audit boundaries. This is the first time the "agent onboarding" narrative has moved from benchmark to product form, and it shows this position won't stay vacant for long.

However, the same summit also provided a necessary constraint on this path. HubSpot's chief product and technology officer Duncan Lennox shared lessons from their internal AI transformation: frontier models alone aren't enough; agents need access to the company's own tools, conventions, workflows, and institutional knowledge—"AI knows a lot about the world, but you need a platform that knows your world." This sentence and ApprenticeBench's seven-month apprenticeship are the same thing: what's deliverable isn't the model, it's the model plus your company's context. So the true product form of "agent onboarding" is probably not a stronger model, but an infrastructure layer that feeds company conventions to the agent and continuously corrects drift.

§ 06 Unsolved Problems

Cost and quotas. Moken says the $200 plan's weekly quota burns through in under a day with Fable or Astra, "the era of subscription-based unlimited use is over." Yamada's experience is that Astra's recommended medium effort tier is most cost-effective, "crank to high or Ultra and it dissolves instantly." Yizhou Wang's complaint represents a real need: "Using Astra for something that only requires a normal human brain is stupid, but other models don't have Astra's CUA capability." A cheap, CUA-capable small model is an obvious gap.

v2 adds three numbers to this point. First, Astra's pricing is more complex than "$10/M input, $50/M output": cached input $1, requests exceeding 272K input tokens are billed at 2× input and 1.5× output for the entire request, Batch and Flex at half price, Fast mode at double—CUA is inherently long-context, and that 272K threshold is easy to hit. Second, ARC Prize's cost table overturns the "lower effort saves money" intuition: under Standard harness, max tier scored 62.7% for $26,098, while medium tier scored only 38.6% but cost $48,090—a model that thinks clearly is cheaper because it takes fewer actions. Yamada's "medium tier is most cost-effective" experience may hold in chat scenarios, but in CUA where you burn money per turn, the math needs reworking. Third, the quota battle is tightening: Anthropic added /limit-reset to Claude Code, but the temporary 50% weekly quota boost expires September 13, replaced by a permanent 25% boost on the 14th—a net effect of ~17% less for eligible subscribers compared to the previous table—landing in the same week as Astra's launch.

Safety checks cause false positives. OpenAI itself acknowledges that additional checks "sometimes interrupt legitimate work" and is continuing to iterate to reduce unnecessary interruptions. Kyle adds a detail: Guardian technically doesn't guarantee seeing the complete a11y tree. For people doing defensive security work, this means Astra currently refuses to write proof-of-concept exploits; more permissive permissions will be gradually opened via OpenAI's Daybreak project—per OpenAI's September 1 "Path to Astra", advanced cybersecurity capabilities are initially available only to a tester cohort, then expanded for defensive use through Daybreak Blue. Astra is also the first model to reach the Preparedness Framework's "Critical" cybersecurity threshold, so the public version outright refuses such tasks.

Website countermeasures. udit found that having Astra scan a website gets blocked by robots.txt, while the same task via Codex's CUA works—"probably will be patched soon." This exposes a bigger question: when agents access websites via human interfaces, should or can websites distinguish them from humans?

Passwords and permissions. The key manager gap FleetingBits identified isn't fully covered by James Sun's governance items either. Today most people run agents by reusing their own browser login sessions—fine for personal use, but this won't pass security review in enterprises.

Judgment remains a weakness. "Too eager to CUA" isn't a problem one model version can fix; it requires harness-layer routing rules, cost awareness, and more training signal about "when not to use GUI."

Long-horizon is completely unvalidated. Kyle and CoArena said the same thing from two directions. 12 hours is the current ceiling, and the best model's median successful run already consumes 6h 22m. Cross-day, cross-shift, waiting for counterpart replies—these real-work norms have no data in public benchmarks. But v2 found a more persuasive number, and OpenAI provided it themselves. Per Berkeley RDI's compilation of OpenAI internal disclosures, by mid-August, OpenAI's research org consumed ~3.1 agent workdays per human workday, and had already achieved the previously announced "automated research intern" goal, with the next target being an automated AI researcher by March 2028. But the other side of the same data: over half of successful 4-to-8-hour agent tasks still required human intervention, with research prioritization and "which result is worth pursuing" still decided by humans. In other words, in the organization that knows best how to use agents, 4-hour-scale tasks haven't been fully automated—so 12-hour tasks at 24% success isn't surprising.

Environment fragility. The 10× variance from the fourth bucket in §04 is an independent engineering risk, not fine print in a benchmark. Same agent, same task—change theme, font, language, or OS version, and success can drop from 90% to 9%. For teams putting CUA into production, this means "we tested it on our machine" has almost no portability value; for founders, it's a clear problem statement: cross-visual-configuration regression testing and adaptive localization.

Compliance and data residency. The Agents API released September 10 makes Codex's harness a managed service with built-in compaction, tool search, programmatic tool invocation, and subagents; the public beta charges no additional fees (only tokens, tools, and container time), with environment choices including OpenAI-hosted, self-hosted codex exec-server, or partner sandboxes from Blaxel, Cloudflare, Daytona, DigitalOcean, E2B, Modal, Oracle, Runloop, and Vercel; early users report latency down to a quarter, per-task cost down 60%, and failed responses down 86%. But it currently offers only US data residency with no zero-data-retention option—for financial, healthcare, and European customers, this alone blocks the entire managed route. Teams that want this harness layer but face regulatory constraints can only go self-hosted in the near term, which also explains why the "build your own CUA harness" business isn't dying anytime soon.

Benchmarks themselves don't test what they should. This is a meta-issue v2 wants to add. "From benchmarks to deployment" (Artificial Intelligence Review) systematically surveyed 15 mainstream agentic benchmarks including AgentBench, WebArena, SWE-bench, GAIA, ToolBench, Terminal-Bench, and Mind2Web, concluding: none incorporate safety testing into scoring, only 2 (WebArena and BrowserGym) do partial cost tracking—and only report action counts with no cost-normalization metric—zero penalize safety-constraint violations in the main metric. The authors' judgment is that evaluation methodology, not model capability, has become the primary bottleneck for reliable deployment: two agents with identical success rates can have completely different resource consumption and failure modes, and binary judgment erases this difference; worse, utility-style benchmarks that don't penalize unsafe solutions effectively encourage agents to bypass safety constraints. Add the 10× variance from static VM snapshots in §04, Anthropic's own declaration of non-comparable task sets, and the 37-point harness gap on ARC-AGI-3, and the honest conclusion is: the precision of all current CUA leaderboards is lower than the decimal point each vendor uses for marketing. Whoever builds "same environment, same harness, simultaneous cost and safety tracking" as public infrastructure will gain the power to define this industry's scoreboard—CUA-Lite aims to do exactly the first half.

§ 07 Our Judgment

First, CUA tax going to zero changes not "whether it's possible" but "how much it costs." Previously, having an API determined whether a workflow could be automated; now it only determines cost. This means all businesses whose moat was "integration difficulty"—including RPA, system integrators, and many SaaS connector companies—are watching their moats shallow; and all the job tasks done manually because "there's no API" now have an automation path for the first time. We're fairly confident about this because OpenAI's enterprise customer data, NeoCognition's quantitative results, and X's first-hand users are all saying the same thing.

Second, the winners over the next six months are in the harness and governance layers, not the model. Model capability is already determined by OpenAI and Anthropic, and both have crossed the line; but translation layers can add another 2.5× speedup, harness mods can turn a game from a trick into a tool, key management and triggers aren't yet built by anyone, and auditing and replay just got their data streams. These are all things founders can touch.

Third, long-horizon performance is the real watershed; until it's validated, "agent onboarding" remains a marketing phrase. 24% 12-hour success rate, "more notes = slower" learning curves, and cross-day tasks that nobody has run all indicate that what can be delegated to agents today is "tasks," not "roles." CoArena's 7-day results and ApprenticeBench's policy-reversal test are the two numbers most worth watching over the coming months. v2 adds a supporting data point: over half of OpenAI's own successful 4-to-8-hour tasks still require human intervention—even they haven't closed the 4-hour gap yet.

Fourth, this is a v2 addition and the point we most want readers to remember: speed and monitorability come from the same mechanism, and enterprises will need to pay separately for this. What makes Astra's CUA faster—preserving invisible reasoning state between requests, using compaction instead of truncation—is exactly what makes its reasoning harder to see through; those 37 percentage points on ARC-AGI-3 are the sticker price of this trade. If part of the model's "thinking" no longer becomes text, what's auditable is only what it "did." This makes OpenTelemetry traces, the eval five-tuple (task/trace/context/artifact/verifier), and OS-level agent identity and container isolation shift from "security team compliance items" to prerequisites for CUA entering production. We're more confident about this than the previous three points, because what's pushing it isn't any one vendor's roadmap but a structural tradeoff.

Research note: source material was collected on September 11, 2026 via ego-browser on X using keyword groups "Astra CUA", "Astra computer use", "GPT-6 Astra CUA", "Astra Codex computer use", covering ~200 tweets and their threads from September 3–11, cross-referenced with OpenAI's launch page and Kyle Jeong's technical blog. All view counts and likes are snapshots at time of collection. The dispute on X about whether demo videos were recorded in real time could not be independently verified; both claims are presented side by side.

v2 update note (September 12, 2026): this round adds first-hand evaluations and official documents beyond X, with sources shifting from tweets to the ARC Prize evaluation report, Anthropic and OpenAI's respective launch pages and safety documents, Snorkel AI and Cua-Bench's professional software evaluations, Steel.dev and Browser Use's public leaderboards, and Berkeley RDI's September 10 weekly digest. Four main changes: (1) corrected v1's juxtaposition of ARC-AGI-3's "7.8% → 99.9%" as same-condition comparison; the numbers span two harnesses, and the comparable figure is 7.8% → 62.7%, see §02 new subsection and Fig 7; (2) annotated the comparability boundaries of the §02 benchmark table, including Anthropic's own statement that task sets are not directly comparable; (3) added fourth bucket of cold water (professional software & environment fragility, Fig 8); (4) added the "speed and monitorability share a source" judgment, plus three third-party infrastructure launches from September 10–11. The Information's report on recurrent depth relies on a single anonymous source; Astra's system card does not name this architecture, and uncertainty is noted in the text.

Sources

Official & Technical Teardowns

• GPT-6 Astra: A new generation of intelligence (OpenAI launch page, with all benchmark tables and safety notes)
• OpenAI official launch tweet: "Anything you can do on a computer, Astra can do for you. Fast."
• How does Astra's computer use actually work? (Kyle Jeong / Browserbase, 2026-09-07, based on Codex & ChatGPT client source)
• What's the big deal about computer-use? (Kyle Jeong, 2025-12-15, vision vs DOM approach survey)
• Kyle Jeong: Stagehand translation layer makes Astra's computer use 2.5× faster
• OpenAI Developers: Agents API public beta (cloud-hosted Codex harness)
• James Sun (OpenAI): enterprise-grade CUA governance & OpenTelemetry auditing
• Maximilian Sieb: farewell post leaving OpenAI's computer use team
• Token Gremlin: pre-launch openai-cua-sample-app PR #71 verification

Benchmarks & Counter-evidence

• CoArena: CUA KnowledgeBench, 12-hour real company work, $50K
• NeoCognition: ApprenticeBench, computer use + on-the-job continuous learning, "No more CUA tax"
• Boyu Gou: strongest agents now succeed more often via GUI than API
• John Rood: the killer test for continuous learning is policy reversal
• Francesco's team: pre-batched actions ≠ real-time decisions, with multi-app demo clips
• Cosmic Raven: piano vs 30 seconds to open File menu
• arjun chintapalli: Cities: Skylines test, "CUA is a party trick; useful agents are solved at the harness layer"
• Max Schoening: "Astra is way too eager to CUA."
• Qingfeng: ignores GitHub CLI, opens Chrome to create issue
• udit: robots.txt blocks Astra but not Codex CUA

First-hand Usage & Opinions

• FleetingBits: new model capabilities reset adoption curves; next wave driven by computer use
• Will Hu: 7 computer use cases 48 hours after Astra launch
• Sanjin: Agent's second half is Computer Use; most direct value is catching legacy systems
• Baoyu: Computer Use lets Agent form a closed loop from development to acceptance
• Baoyu: GPT-6 Astra launch & Greg Brockman's AGI statement
• Kevin Kern: Blender CLI + MCP + Computer Use three-layer configuration
• Brent Schooley: in DaVinci Resolve, Astra uses scripts where possible, switches to CUA otherwise
• cosine: Figma dev MCP no longer needed
• Bilawal Sidhu: 3D scan to editable scene, "inverse graphics chasm crossed"
• Sac: Codex operates Jianying for rough cuts; official harness speedup note
• Kyle Balmer: all YouTube long videos edited by Codex and uploaded via CUA
• AWAMORI: Illustrator design-to-code slicing, consumed 15% of Pro 5x weekly quota
• quark_h: Mac remote-operating Windows VM for client testing
• Jesse Lau: portraits waste tokens; TradingView trend lines are the correct use
• Yenpro Musik: "Agents like to say they're done"
• Moken: $200 plan burns through weekly quota in one day
• Yizhou Wang: need a cheap model with CUA capability
• KEITO: Canva portrait, 840K views
• Alexey Fateev: Paint comparison Astra vs Fable 5.1, 1.19M views
• Tykoo: Astra's Blender craze muddied the "world model" definition
• Flrande: Codex Desktop's harness leads
• Xiong Bulang: gap between open-source cua and Codex computer use

v2 Additional Sources (2026-09-12)

• OpenAI's GPT-6 Astra on ARC-AGI-3 (ARC Prize, Greg Kamradt, 2026-09-03, full scores & cost table for two harnesses, PRO-LONG self-built tools, "not claiming this is AGI")
• The Next Web: Astra's AGI score comes from harness not model (with Claude Opus 5 under NVIDIA AVO / AWS Strands comparison)
• Path to Astra: critical capabilities and frontier safeguards (OpenAI, 2026-09-01, jailbreak refusal rate, scope convergence, Daybreak Blue, RL restart timeline)
• Introducing the Agents API (OpenAI, 2026-09-10, managed harness, three sandbox environments, data residency limits)
• Introducing Claude Fable 5.1 and Claude Mythos 5.1 (Anthropic, OSWorld 2.0 partial/strict scores & "task sets not directly comparable" footnote)
• Cua-Bench: benchmarking computer-use agents on professional software (Snorkel AI, 25 KiCad expert tasks results & failure modes)
• Cua-Bench leaderboard & framework docs (trycua, open-source MIT; includes OpenApps environment variant study citing 10× score variance)
• Online-Mind2Web Leaderboard (Steel.dev, live-web leader is specialized harness not frontier model)
• browser-use/online-mind2web: bu-max 291/300 public eval repo & failure case judgments
• Agentic AI Weekly (Berkeley RDI, 2026-09-10: CUA-Lite release, OpenAI internal agent workday data, Project Zenith, Grok Bot for Enterprise, evals & governance discussion at summit)
• Fortune: recurrent depth safety controversy, with Pachocki's rebuttal and Redwood Research's critique
• Sebastian Raschka: looped transformer & chain-of-thought visibility technical analysis (rejects the causality)
• Fortune: Astra launch event, Brockman's computer use statement & Aidan Clark's 100K GPU pre-training note
• Eigenwise: running Astra inside Claude Code became the dominant configuration of the moment
• From benchmarks to deployment: a comprehensive review of agentic AI evaluation (Artificial Intelligence Review, safety & cost blind spots across 15 mainstream agentic benchmarks)

Author: Feng Xiaoping, [email protected]