Frontier cloud vs local ownership
Every time a “more capable” model ships, the practical question is not whether it saturates a leaderboard. It is where I want the work to live: on a hosted API with managed tools, or on a GPU I control.
GPT-6 Astra, announced by OpenAI in September 2026, is the company’s most capable model for hard end-to-end work: reasoning, coding, computer use, research, and documents. At the same time, the open-weight ecosystem —Qwen3-Coder, Devstral, gpt-oss, DeepSeek, GLM— keeps closing gaps on engineering tasks that two years ago felt frontier-only.
This post is not “cloud wins” or “local wins.” It is an honest comparison of what each can do in software engineering, on which hardware, at what cost, and with which privacy, offline, and control constraints. I use figures from the OpenAI announcement and the API docs, and I label third-party benchmarks (Real-SWE, community hardware guides) as secondary reports —not gospel.
What GPT-6 Astra is
According to the official docs, the API id is gpt-6-astra. OpenAI positions it as the most capable model for the hardest end-to-end work. Product numbers that matter:
| Dimension | Value (OpenAI docs) |
|---|---|
| Context | up to 1,050,000 tokens |
| Max output | 128,000 tokens |
| Knowledge cutoff | Apr 30, 2026 |
reasoning.effort |
low, medium, high, xhigh, max |
| API price (approx.) | ~$10 / $50 per 1M input/output tokens (subject to change; long-prompt multipliers, cache, batch, flex, and fast mode apply) |
Tools that matter for engineering —via the Responses API— include web search, file search, code interpreter, hosted shell, apply patch, skills, computer use, MCP, and tool search. That is not “chat with autocomplete”: it is a cloud harness with shell, patches, browsing, and skills.
Rollout covers ChatGPT (Plus, Pro, Business, Enterprise), the API, Azure, and Bedrock. On Enterprise, as usual with new capabilities, an admin may need to enable it.
Software engineering claims (OpenAI)
From the announcement and public launch tables:
- Terminal-Bench 4.0: 57.9%
- DeepSWE v1.1: 74.1%
- Artificial Analysis Coding Agent Index (per OpenAI’s table): ~67
- On computer/browser use, OpenAI reports ~1.9× faster vs GPT-5.6 Sol on Mind2Web with an updated Codex harness
OpenAI also positions Astra as SOTA on computer use, browsing, software engineering, and science. An important safety nuance: under Preparedness, Astra meets the Critical threshold for cyber capabilities; that means restrictions on advanced cyber help, not an offensive free-for-all. For engineers running agents in production, that cuts both ways: more capable and more constrained on certain task classes.
Real-SWE: the private-enterprise floor
A third-party benchmark I care about more than saturated public-repo scores: Real-SWE (Specific Labs, Sep 2026). According to published leaderboard reports, Astra + Codex CLI lands at ~33.8% pass@1 on private enterprise tasks; Claude Fable 5.1 + Claude Code led at ~38.8%.
The lesson is not “Astra loses.” It is that private enterprise code is still hard for every model, including the frontier. If you expect an agent to clear 90% of billing/tax/migration tickets in an unfamiliar monolith, Real-SWE is the cold shower.
What “most advanced local” means
Be precise: local ≠ open-weight on a rack. Many “best open-weight” checkpoints live on clusters or third-party APIs. For this post, “practical local” means what you can run on reasonable hardware without lying to yourself about VRAM.
Tier 1 — Single GPU ~24 GB (everyday)
The standout I recommend most for day-to-day coding on a 24 GB card is Qwen3-Coder 30B-A3B (MoE, ~3B active). Apache-2.0. At Q4, community guides put the footprint roughly in the ~17–22 GB range depending on context (quantized.uk / localmodel.run / Hardwarepedia — estimates, not gospel). Long native context (256K, extensible), a solid fit for FIM, edits, and short agent loops.
Also in this tier, per community reports and Mistral’s own materials: Devstral Small 2 (24B) —aimed at multi-file agentic work— fits consumer GPUs (RTX 4090 / equivalents) with careful quantization. Useful when the harness (Cline, Continue, Aider, Vibe, etc.) matters as much as the weights.
Tier 2 — One “serious” card (~80 GB) or workstation
gpt-oss-120b (~117B MoE, ~5B active, Apache-2.0) fits, according to guides such as dreaming.press (Sep 2026, community hardware guidance), on a single ~80 GB GPU (H100 / MI300X) with MXFP4 (~60 GB weight footprint). That is no longer a laptop: it is a private agent backend on a node.
Tier 3 — Open-weight giants (not “your notebook”)
DeepSeek V4 Pro, Qwen3-Coder 480B, GLM-5.x, and peers: higher raw capability, but not desktop-local. They live on racks, open-weight clouds, or APIs. Comparing them to Astra as if they were “free on my Mac” warps the decision.
| Tier | Example | Typical hardware | Role |
|---|---|---|---|
| Everyday local | Qwen3-Coder 30B-A3B | 24 GB Q4 | Autocomplete, edits, short agents |
| Agentic 24 GB | Devstral Small 2 24B | 24 GB (quantized) | Multi-file, tool use |
| Private node | gpt-oss-120b | ~80 GB | On-prem agent backend |
| Open-weight frontier | Qwen3-Coder 480B, DeepSeek V4 Pro, GLM-5.x | Cluster / API | Near-cloud capability, not laptop ownership |
Software engineering task matrix
The useful question is by task, not by brand. Below, “strong local” = the best that fits in 24–80 GB with a decent harness; “Astra” = model + hosted tools (Codex / Responses).
| Task | Who usually wins | Why |
|---|---|---|
| Autocomplete / FIM | Local (practical tie) | Latency and marginal cost: a ~3B-active MoE on a local GPU answers without a round-trip. Astra is overkill for completing a line. |
| Single-file edit | Tie / slight local edge in the loop | Small diffs: Qwen3-Coder / Devstral are enough. Astra shines when the edit needs design judgment or web research. |
| Multi-file feature | Astra (clear margin) | Planning, apply patch, shell, and reliable long context. Agentic locals (Devstral, Qwen3-Coder) try; they fail more often on cross-file coherence. |
| Debug a production incident | Astra | Logs + hypotheses + tools + doc browsing. Local helps grep and propose; root-cause judgment and hosted tools weigh heavily. |
| Architecture design | Astra | Trade-offs, alternatives, risk. Locals draft decently; the frontier holds business constraints better across a long thread. |
| Test generation | Tie tilting local for volume | Unit/property tests: local is cheap. Hard integration tests or flaky diagnosis: Astra. |
| Large migration / refactor | Astra | Huge context windows + shell + patch. Locals with 256K help, but reliability of long context and long loops favor the frontier. |
| Security review | Astra with a human | Astra reasons better about vulnerability classes; Critical cyber restricts advanced offensive help. Local is useful for scanners + private triage without uploading the repo. |
| Computer-use / browser agents | Astra | OpenAI positions it as SOTA; native computer-use tools. Locals with browser tools exist, but the judgment + robustness gap is large. |
| Long-horizon agent loops | Astra | Less drift, better tool use, skills, and MCP. Local wins on privacy and cost when the loop is short and scoped. |
How to read the matrix
For the inner loop (complete, edit, generate tests, small refactors), a strong local is already “good enough” and often better on $/token and latency. For the outer loop (incident, architecture, migration, an agent that browses and patches for hours), Astra —or a frontier peer— is still the ceiling.
Real-SWE (~34% Astra, ~39% Fable on private tasks) is the reminder that even the ceiling is not magic: private enterprise rules, unfamiliar architecture, median ~11 files touched still break agents.
How far local is from the frontier
Honest gaps, no marketing:
- Engineering judgment. Not just “write the patch”: decide what not to touch, which ADR to write, which risk to accept. 24–120B open-weight models improved a lot; the frontier still generalizes better under ambiguity.
- Reliable long context. Shipping 256K or 1M on a datasheet is not the same as using that context well. Astra offers up to ~1.05M with a product built for Codex windows / searchable prior windows; locally, KV cache, quantization, and “lost in the middle” remain real friction.
- Robust tool use. Hosted shell, apply patch, computer use, MCP, and skills cut the glue code you must maintain. Locally, the harness (Ollama + Continue, vLLM + OpenHands, etc.) matters as much as the checkpoint —and varies more.
- Cyber and research agents. High capability + Preparedness policy: the cloud frontier has both a ceiling and brakes. Local open-weight lacks the same safety product —and the same computer-use ceiling.
- Private-code resolution. Even Astra+Codex is ~33.8% on Real-SWE. The local↔frontier gap matters, but the gap agent↔senior engineer on an unfamiliar repo is still the one that hurts most.
Said the other way: on autocomplete, unit tests, and scoped features with a good harness, the gap feels small. On “fix this payments incident across three services with internal runbooks,” it feels huge —and sometimes the frontier does not close it alone either.
When to use each (hybrid recommendation)
My mental model today:
Use local when…
- Code or data must not leave the machine (PII, IP, compliance).
- You need offline or millisecond IDE latency.
- Volume is high: thousands of completions/day where $10/$50 per million adds up.
- The task is FIM, single-file edit, tests, internal docs, scanner-based triage.
- You can pin the model (Qwen3-Coder 30B-A3B or Devstral Small 2 on 24 GB; gpt-oss-120b if you have the node).
Use Astra when…
- You need computer use, serious browsing, research + patch in one loop.
- The work is multi-file, migration, architecture, or an ambiguous incident.
- You want the managed harness (Codex, shell, apply patch, skills, MCP) without operating vLLM.
- The cost of a human error exceeds token cost at ~$10/$50 per million.
- You are already on Azure/Bedrock/Enterprise with a compliance path to OpenAI.
Hybrid that works for me
- Local handles 70–80% of volume (completions, drafts, tests).
- Astra (or a frontier peer) reviews, designs, and unblocks the hard 20–30%.
- CI + eval (tests, linters, secret scanning, human review) as the outer loop —model-independent.
- Never upload secrets “because the model is good.” The model is not your security boundary.
| Scenario | I lean toward… |
|---|---|
| Startup, semi-public repo, little PII | Astra + Codex for features; local for autocomplete |
| Bank / health / gov with sensitive data | Local / VPC open-weight first; frontier only with contract and redaction |
| 24 GB laptop, travel, airplane | Qwen3-Coder 30B-A3B or Devstral Small 2 |
| 80 GB on-prem workstation | gpt-oss-120b as an internal agent backend |
| “Can the agent close the tax-jurisdiction ticket?” | Neither local nor frontier alone: human + harness + domain |
A concrete workflow I use
- Open the IDE with Qwen3-Coder 30B-A3B (or Devstral Small 2) for FIM and small edits: no network latency, no cloud tokens.
- When a feature crosses three or more files with ambiguous contracts, switch to Astra/Codex: ask for plan → diffs → tests → PR description.
- If the incident involves prod logs + external docs + an internal runbook, Astra with file search / shell; local only greps what I already pulled down.
- Security: local scanners and SAST first; Astra to explain risk classes and remediation —without asking for exploits. Critical Preparedness is not a marketing footnote.
- Close with CI: tests, lint, secret scan. The model does not merge.
That workflow does not maximize a benchmark. It maximizes control of secrets and ceiling where it hurts.
Cost: not just price per million
At ~$10 / $50 per 1M (per docs; can change), a long agentic session with high/xhigh/max reasoning plus tools is not cheap. Input cache ($1 / 1M cached per docs) helps repetitive loops. Batch/Flex at 50% help async work. But local’s real cost is CAPEX (GPU), power, ops time (vLLM, quantization, tool-calling templates), and the risk of a misconfigured harness.
If your team already burns hundreds of dollars/day on cloud agents, an 80 GB node with gpt-oss-120b can pay for itself. If you are a solo engineer with a 4090, Qwen3-Coder 30B-A3B is usually the sweet spot: Apache-2.0, fast MoE, enough for the inner loop.
Conclusion
Astra raises the ceiling of the cloud agent with tools: huge context, reasoning effort up to max, computer use, coding, and research in one product. Official Terminal-Bench / DeepSWE / Coding Agent Index numbers are strong; Real-SWE reminds us the private-enterprise floor is still low for everyone.
Local models are not “Astra but free.” They are a different curve: ownership, privacy, latency, and marginal cost, with a lower ceiling on long-horizon judgment and computer use. On 24 GB, Qwen3-Coder 30B-A3B and Devstral Small 2 are already serious everyday engineering companions. On 80 GB, gpt-oss-120b is a credible private backend. Open-weight giants on racks approach the frontier —but they stop being “local” in the laptop sense.
The mature decision is not picking a side. It is routing tasks to the right ceiling and keeping human judgment where Real-SWE says we still fail ~60–70% of the time.
Official links
Third-party (labeled): Real-SWE / Specific Labs (Sep 2026); Artificial Analysis if you cross-check Coding Agent Index; community hardware guides (dreaming.press and similar) for VRAM footprints.
Versión en español: /blog/2026-09-19-gpt-6-astra-vs-modelos-locales