CosavuThere is a tempting interpretation of GPT-6 Astra: connectors are dead, MCP is dead, the agent can simply use the computer.
That interpretation is directionally interesting and architecturally incomplete. Astra changes something more fundamental than the transport. It makes connectivity cheap.
Until now, an agent's ability to work inside an enterprise was constrained by interfaces. Salesforce needed an API. An internal application needed a connector. An agent needed tools, schemas, or an MCP server. Legacy software without those interfaces stayed expensive to automate.
Computer use changes the default. If software is visible to a human, it is increasingly visible — and operable — to an agent. OpenAI reports Astra at 72.6% on OSWorld 2.0 against 65.7% for GPT-5.6 Sol, at roughly 47% less time per task in its latency simulations. 92.7% on ScreenSpot-Pro without tools. 59.3% on Agents' Last Exam. OpenAI describes the workflows directly: updating CRM records, operating spreadsheets, filling forms, running research, testing software, working inside professional applications.
The screen is becoming a universal compatibility layer.
But a screen is a remarkably good interface for a human and a remarkably bad representation of enterprise context.
01Astra did not delete the integration layer. It changed its economics.
There are now three practical ways an agent can reach enterprise software. They differ on every axis a deployment actually cares about.
| Structured | Semi-structured | Computer use | |
|---|---|---|---|
| Access mechanism | API / MCP / connector | Browser / DOM | Screen, keyboard, mouse |
| What the agent sees | Typed objects and fields | Page structure | Pixels and rendered UI |
| Payload per interaction | 10²–10³ tokens | 10³–10⁴ tokens | 10⁴–10⁵ tokens, every step |
| Integration effort | Higher upfront | Medium | Very low |
| Runtime context entropy | Low | Medium | High |
| Determinism | High | Medium | Probabilistic (grounding) |
| Failure behaviour | Usually explicit | Often detectable | Can be semantically silent |
| Auditability | Strong — native call log | Reconstructable | Requires external control |
| Coverage | Systems exposing interfaces | Browser-accessible systems | Almost anything visible |
| Best use | High-value repeatable workflows | Web workflows | Long-tail, legacy, human-only software |
Computer use removes the requirement to build a connector before an agent can reach a system. It does not remove the need to understand the system.
That distinction will matter enormously in enterprise deployments. An API response might return:
customer_tier = enterprise invoice_status = overdue country = Singapore credit_limit = 250000
A computer-use agent receives the same information as a rendered screen containing navigation, logos, buttons, tooltips, sidebars, historical records, alerts, unrelated fields and formatting. The first representation is already compressed around meaning. The second requires the model to reconstruct meaning from presentation.
Computer use reduces integration cost by increasing context-processing responsibility. That trade is worth making for thousands of workflows. It is not free.
Click image to open full size
02Read the scoreboard as an operator, not as a benchmarker
The scores are real and the jump is large. The interesting number in each row is the residual.
Figure 4 — The computer-use scoreboard
Frontier scores are real. The residual is where enterprise risk lives.
Source: OpenAI, GPT-6 Astra (Sept 2026). Opus 5 OSWorld on the official leaderboard; ScreenSpot-Pro not reported for Opus 5.COSAVU
| Metric | Astra | Prior frontier | What it constrains in production |
|---|---|---|---|
| OSWorld 2.0 (offline set) | 72.6% | 65.7% Sol · 70.2% Opus 5 | Roughly one desktop task in four does not complete — on a generic desktop, not your line-of-business stack |
| Time per OSWorld task | ~40 min | ~75 min | A 40-minute window of autonomous action across systems of record, per task |
| ScreenSpot-Pro (no tools) | 92.7% | 76.9% Sol | Grounding is much better, not solved. The residual is silent misclicks, not thrown exceptions |
| Agents' Last Exam | 59.3% | 53.6% Sol · 55.5% Opus 5 | Complex professional work in real software is now roughly a coin-flip-plus |
| Internal computer-use safety eval (lower is better) | 2.4% | 22.0% Sol · 11.5% Opus 5 | An order-of-magnitude improvement — and still non-zero, on a benchmark chosen to be adversarial |
| Overreach on impossible-task eval | 0% | 48% Sol (no production safeguards) | Materially better scope discipline. Measured without the safeguards enterprises would run |
Read the safety row twice. A 2.4% rate of unintended consequence is a remarkable research result and an uncomfortable operating parameter, because the denominator in a bank is not benchmark tasks. It is transactions.
03The interface problem is becoming a context problem
Atlan has been articulating one of the more useful definitions in this space: enterprise context is not simply data. It is the knowledge, expertise, rules, definitions, lineage, policies and organisational meaning required for AI to understand how a company actually works. Atlan's own framing is sharper than most — data is what is; context is what it means — and its architecture treats context as infrastructure rather than a retrieval feature, spanning an enterprise data graph, context agents, a context engineering studio and a context lakehouse.
That distinction becomes more important with computer-use agents, not less. Picture an Astra-class agent looking at an insurance claims application.
The screen can tell it:
Claim amount $48,200 Status Pending Region APAC Policy Enterprise Gold
The screen cannot tell it:
- that "Pending" means something different in claims than in underwriting;
- that claims from this jurisdiction above $40,000 require a second reviewer;
- that this policy version was superseded last quarter;
- that this broker has a known data-quality defect in the loss-date field;
- that this customer has a negotiated exception;
- that the agent may read this field, but its delegated user cannot approve it;
- that this business unit calculates exposure using a different definition.
The model can become nearly perfect at reading the screen while remaining wrong about the business. This is the difference between perception accuracy and context accuracy.
Astra attacks perception. Enterprise context infrastructure attacks meaning. The two are complements, not substitutes.
It is also the honest explanation for the OSWorld residual. 72.6% is measured on a generic desktop where tasks are largely self-describing. Your desktop is not self-describing. The gap between a benchmark score and a production success rate is, almost entirely, the context gap — and it does not close by improving the model's eyesight.
04The Pixel Tax
With a structured interface, software performs part of the context engineering before the model is invoked. A schema tells the agent what a value represents, what type it has, what operation is valid, what object changed, and whether the call succeeded.
With computer use, most of that must be reconstructed. The model receives presentation and has to infer state. And long-running GUI agents observe changing environments repeatedly. That creates four distinct taxes.
- The observation tax. Screens contain far more information than the current decision requires, and you pay for all of it.
- The interpretation tax. The model must recover structure and state from presentation, every step.
- The memory tax. Long-running tasks accumulate observations, decisions, results and intermediate state — and naive loops re-bill all of it on every call.
- The retry tax. Ambiguous actions or weak grounding trigger replanning, additional screenshots and additional inference.
The memory tax is the one most teams under-model. In a naive loop, step N is billed for the observations of steps 1 through N, so total cost scales with the square of the step count rather than the step count. Attach the computer-use constant to that curve and the arithmetic gets uncomfortable quickly.
This is not speculative. Research on long-horizon GUI agents already treats expanding interaction history as a fundamental context-management bottleneck. AgentProg, for example, restructures long GUI-agent histories around explicit program state so irrelevant history can be discarded while important information is retained — and reports per-task consumption in the range of hundreds of thousands of prompt tokens for the baselines it compares against.
Figure 2 — The token physics of an agent loop
Billed input tokens accumulate quadratically when nothing governs the context.
Illustrative model: 14k tokens/step, 60 steps. Shape is the point, not the constant.COSAVU
And then there is the cliff
Astra ships with a 1,050,000-token context window and a maximum output of 128,000 tokens. Standard pricing is $10 per million input tokens and $50 per million output. Cached input drops to $1; cache writes bill at $12.50.
Then the detail that most launch coverage skipped. Per OpenAI's own API documentation, prompts above 272,000 input tokens are priced at 2x input and cache rates and 1.5x output — for the full request, not only the tokens above the line. A long request runs $20 in and $75 out.
272K is roughly 26% of the advertised window. An ungoverned screenshot loop does not approach that threshold gradually — it crosses it in the middle of a long task and re-prices everything behind it. This is not a slope. It is a cliff, and the agent has no reason to notice it.
| Scenario | Input tokens | Output tokens | Rate band | Approx. cost |
|---|---|---|---|---|
| Structured call, governed context | ~15,000 | ~2,000 | Standard | ~$0.25 |
| GUI agent, lean context management (UI-TARS-class, third-party benchmark) | ~315,000 | ~3,200 | Long-context | ~$6.54 |
| GUI agent, reflection and summarisation loop (Mobile-Agent-v3-class, same benchmark) | ~809,000 | ~22,100 | Long-context | ~$17.84 |
A ~26x to ~71x spread on the same unit of business work, driven not by model choice but by how much context the loop admitted and whether it crossed a pricing threshold nobody was watching.
There is a real counter-argument. A stronger model needs fewer retries, and a cheap model that needs six attempts can cost more than a frontier model that succeeds once. OpenAI leans on this directly: on one coding benchmark Astra's best configuration beats its predecessor's best at roughly 57% lower estimated cost per task, and on Agents' Last Exam it reportedly uses around 65% fewer output tokens than Claude Opus 5 at their respective best settings. Artificial Analysis found Astra can undercut rivals on coding because it finishes in fewer tokens — while running roughly 75% more expensive per general reasoning task than Sol at maximum effort.
That argument is correct and it does not rescue the loop. Fewer retries reduces the step count. It does not touch the per-step constant, and in a quadratic regime the constant is multiplied by every step that remains. A better model makes an ungoverned loop cheaper. It does not make it cheap.
05A million-token window is capacity, not permission
One standing response to the context problem has been that models will eventually have windows large enough that retrieval and compression stop mattering. Astra makes that argument harder to sustain, not easier.
The model that shipped the 1.05M window shipped context engineering alongside it. Astra is trained to pull only the information that matters into its outputs rather than repeating what the task does not need. In Codex it can keep notes across context windows instead of compacting them into a single lossy summary, with earlier windows left searchable — so it can recover a requirement or a test result even when its own notes missed it. It scores 96.3% on the 512K–1M long-context retrieval band against 73.8% for its predecessor.
Those are not capability features. Those are context-management features, shipped inside the model because the loop could not carry the load otherwise.
Context capacity is not context quality. A million-token window is capacity. It is not permission to send a million tokens.
The enterprise objective is therefore not to maximise context utilisation. It is to minimise context required per successful business outcome.
06This is not a computer-use-only problem
The cleanest available evidence that the bottleneck is allocation rather than transport comes from a structured-interface comparison, not a pixel one.
In an internal benchmark of 180+ enterprise tasks published in August 2026, Glean reported that its auto-routed assistant consumed 1.3 million tokens against 4.4 million for Claude Cowork — a 70% reduction — producing an 81% lower token cost, $0.58 per task against $2.98, while graders preferred its answers 78% of the time. Glean commissioned and ran the benchmark, so read the numbers as vendor-reported rather than independent.
The mechanism Glean describes is the part worth taking seriously. It attributes the gap in part to Cowork's federated MCP approach, which searches each connected system individually and therefore overfetches, normalises, resolves conflicts and repeats reasoning loops. Glean starts from a unified, pre-indexed, permission-aware view and cuts the context-retrieval work the model has to do.
An MCP-native architecture with no context layer above it was the expensive side of that comparison. Structured transport did not save it. The saving came from deciding, before inference, what was worth retrieving.
Which means the pixel tax is a specific and severe instance of a general problem, not a problem created by pixels.
07The next stack is not "agent plus MCP"
What is emerging across OpenAI, NVIDIA, Atlan, Glean and the wider agent ecosystem looks less like one monolithic agent and more like independently evolving infrastructure layers, each solving a different optimisation problem.
Click image to open full size
| Layer | Core question | Example direction | What gets optimised |
|---|---|---|---|
| Enterprise context substrate | What does the company know, and what does it mean? | Atlan, Glean, systems of record | Semantics, lineage, permissions, memory, retrieval |
| Context intelligence | What deserves to enter this inference call, and can we prove why? | Cosavu / STAN | Context accuracy, tokens, model choice, output scope |
| Agent intelligence | How should the task be reasoned about and executed? | GPT-6 Astra, other frontier and open models | Planning, reasoning, tool use, computer use |
| Action interface | How does the agent reach the system? | MCP, API, browser, computer use | Coverage, determinism, integration cost |
| Compute fabric | Where should this inference physically run? | Cloud runtimes, NVIDIA PAIR | Utilisation, concurrency, privacy, latency |
This is why declaring MCP dead misses the more consequential shift. MCP becomes one transport mechanism inside a larger context architecture. For deterministic, repetitive, high-value operations, structured interfaces remain extremely attractive. For the long tail of software, computer use may win because integration cost approaches zero.
The durable layer is the one above both: the system that decides what the agent is allowed to know, what is relevant, and how much intelligence the decision is worth.
08The data layer is becoming a context layer
Atlan: from metadata to governed business meaning
Atlan's direction is significant because it treats context engineering as an engineering discipline. Build, test, review and deploy applied to business context itself. It argues context should stay portable across models and agent environments rather than being trapped inside one agent, and that a context layer has to operate at the speed of inference rather than the speed of storage.
That is the right architectural instinct, and computer use validates it. The important asset was never the connector. It is the accumulated organisational meaning behind the connector.
If tomorrow an Astra-class model reaches Salesforce through pixels instead of MCP, the company's definition of qualified pipeline does not disappear. Its lineage does not disappear. Its permissions do not disappear. Its exceptions do not disappear.
The access mechanism can change every year. Enterprise context cannot.
Glean: context enters the economics layer
Glean is attacking the same problem from the retrieval side — broad application connectivity across more than 250 systems, indexing, enterprise relationships, permissions, memory, model routing, an AI gateway, agent orchestration and governance. Its benchmark work makes the point this whole piece rests on: context quality is not merely an accuracy problem. It is a compute-economics problem.
Search infrastructure became knowledge infrastructure. Knowledge infrastructure is becoming context infrastructure. Context infrastructure is becoming execution infrastructure.
09NVIDIA PAIR shows the mirror problem
A second shift landed almost simultaneously. NVIDIA introduced PAIR — Personal AI Router.
PAIR is worth understanding precisely, because it is easy to over-read. It is not a new agent framework and not a new inference engine. NVIDIA describes it as a virtual inference router for machines on a local network. When a lead agent creates independent subagent jobs, PAIR routes each request to an eligible node — RTX systems, DGX Spark, Apple silicon — behind a single Ollama- or OpenAI-compatible endpoint, with no changes to the agent harness. It routes each request to one node. It does not pool GPU memory, shard a model, or split an in-flight request.
In NVIDIA's five-subagent demonstration, a three-device cluster completed in 8 minutes 48 seconds against 18 minutes on a single RTX Spark laptop. NVIDIA labels this explicitly as an unofficial, configuration-specific demo rather than a general benchmark or a promise of linear scaling, and it is a home and workstation product rather than a datacentre one.
The architectural signal is what matters. Agents have become sufficiently parallel that inference placement itself now needs a scheduler. To a user, a research task is one task. To infrastructure it may be dozens of independent inference calls.
NVIDIA is asking: which compute node should execute this request?
The context layer has to ask the question immediately before it: does this request deserve to exist, what information does it need, and how much intelligence should be allocated to it?
PAIR routes compute. Context intelligence routes information and reasoning budget. These are two sides of the same emerging infrastructure problem.
10Where Cosavu fits
Cosavu's opportunity is the inference boundary.
It decides how much of that context deserves to reach intelligence for this specific action.
Consider a financial reconciliation workflow. The enterprise may hold hundreds of relevant assets:
13 policies 12 prior reconciliation events 8 transaction tables 3 exception procedures 46 invoices 19 emails 4 account definitions 2 regulatory instructions
A search system can discover them. A context layer can identify what they mean and which are trusted. The inference call still needs a further decision.
Which five facts are necessary now? Does the model need the entire policy, or one exception clause? All 46 invoices, or the two transactions causing the mismatch? Does this require the frontier model, or can a smaller one resolve it? Should the agent return a 1,000-token explanation, or a five-field structured decision? Should a contradictory policy escalate to a human before another expensive reasoning pass?
These are context-allocation decisions. That is the design premise behind STAN: treat context as a constrained resource and learn how to allocate it against quality, cost, latency, policy and workflow objectives. It sits in front of whichever frontier model an enterprise has already contracted, and it is model-neutral by design — because the argument above is model-neutral.
Click image to open full size
11The unit of optimisation has to change
AI teams still measure infrastructure in model-centric metrics: benchmark scores, model latency, input tokens, output tokens, context-window size. Those are necessary. They are no longer sufficient.
| Metric | What it measures | Business outcome |
|---|---|---|
| Context precision | How much admitted context was actually useful | Lower token and compute waste |
| Required-evidence recall | Whether all evidence needed for the decision was present | Higher accuracy |
| Trust / provenance coverage | Whether claims map to authoritative sources | Lower hallucination risk |
| Context compression ratio | Raw available context against context actually sent | Lower inference cost |
| Tokens per successful workflow | Total input, output and retries required for completion | Real AI unit economics |
| Compute per successful workflow | Aggregate model effort across primary agent and subagents | Infrastructure efficiency |
| P95 workflow latency | End-to-end time, not model response time | User experience |
| Retry / replan rate | How often agents need another reasoning loop | Cost and reliability |
| Human escalation precision | Whether humans are pulled in only when necessary | Operational efficiency |
| Successful outcome per dollar | Tasks completed correctly per unit of AI spend | CFO-level ROI |
The denominator is the whole argument. A cheap model that needs six attempts is expensive. A frontier model that succeeds once is cheap. A sophisticated agent supplied with irrelevant context is more expensive than both.
The metric is cost per successful business outcome.
Not cost per million tokens. Not model price. Not agent runs.
12The future is hybrid, not pixel-only
Computer use will become an enormous part of agentic computing. But the best enterprise architectures will not force every action through pixels. They will select the highest-quality interface available, then govern all three under one policy.
Click image to open full size
The agent should not have to carry every schema, every connector description, every retrieved document, every screenshot and every historical action inside its reasoning state.
The model should reason. The context infrastructure should determine what it deserves to reason over.
13What would prove this wrong
An argument worth publishing should state the conditions under which it fails.
- The cost argument weakens if token prices fall faster than agent step counts rise, or if caching and in-model context management close the gap unilaterally. Both are plausible. Astra's cross-window notes and $1 cached input are genuine steps in that direction.
- The accuracy argument weakens if frontier computer-use scores on domain-specific, enterprise-realistic task suites converge on generic-desktop scores. That would mean models are recovering enterprise semantics from pixels alone. There is no public evidence of this yet, but it is a measurable claim and someone should measure it.
- The governance argument does not weaken. No improvement in model capability produces an access log. An audit record is an artefact of architecture, not of intelligence.
That asymmetry is why we think the control plane is a durable layer rather than a temporary patch. Two of the three arguments erode with model progress. The third strengthens with it, because capability without a record is precisely the thing that scales badly.
14What comes after MCP
Not "no MCP." Something more consequential. MCP becomes an implementation choice rather than the boundary of agent capability.
Astra-class systems can reach applications where no integration exists. Context platforms preserve organisational meaning independently of how the application is reached. Context intelligence allocates only the information the current outcome requires. Compute routers determine where the resulting inference executes.
The application interface is becoming universal.
Enterprise context remains proprietary.
Compute is becoming schedulable.
The control plane between them becomes strategic.
That is the architecture we think the next generation of enterprise agents will require, and it is the layer we are building toward. Not another model. Not another system of record. Not another connector library. An intelligence infrastructure layer that takes enterprise context and determines how efficiently it should become inference — optimising for context accuracy, token consumption, compute, latency and business outcomes.
Because as agents become capable of operating almost any software, the scarce resource will no longer be access. It will be discipline.
The discipline to know what information matters. The discipline to know what can be ignored. The discipline to know when more intelligence is worth paying for. And the discipline to prove why an agent knew what it knew before it acted.
The computer-use era does not make context engineering obsolete. It makes context engineering infrastructure.
Cosavu builds intelligence infrastructure for enterprise AI. STAN is a context control plane that governs what reaches your models on every inference call — model-neutral, and layered on top of your existing LLM contracts rather than replacing them.