AI Dev Weekly is a Thursday series where I cover the week’s most important AI developer news, with my take as someone who actually uses these tools daily.
This was the busiest model week of the series so far. OpenAI filled out the GPT-6 family with a serious coding model and a remarkably cheap volume model. Anthropic replaced its Opus flagship with a faster, less expensive release. SpaceXAI moved Grok further into long-running coding work. And GitHub added the controls needed to run those increasingly capable agents on a developer machine without treating trust as a checkbox.
The shared theme is not simply higher benchmark scores. Every launch competes on the cost and operational shape of a completed task: reasoning effort, caching, tool loops, sandbox boundaries, and traces.
1. GPT-6 Sol and Luna turn one architecture into two very different products
OpenAI released GPT-6 Sol and GPT-6 Luna in the API on September 22. Both accept text and image inputs, return text, and expose the same unusually large limits: a 1,050,000-token context window and up to 128,000 output tokens.
That is where the similarity stops.
| Model | Intended role | Input / cached / output per 1M tokens |
|---|---|---|
| GPT-6 Sol | Complex coding and agentic workflows | $2 / $0.20 / $10 |
| GPT-6 Luna | Focused, high-volume tasks | $0.10 / $0.01 / $0.50 |
According to the official OpenAI Docs for GPT-6 Sol and GPT-6 Luna, Sol costs exactly twenty times Luna at every standard text-token rate, including cache writes. Both support reasoning from none through max, with medium as the default.
There is an API boundary that is easy to miss. Built-in tools and normal reasoning tool loops require the Responses API. Chat Completions supports function calling only when reasoning effort is set to none. A model appearing on both endpoints does not mean the endpoints expose identical agent behavior.
Long context also has the same price cliff as Astra. Above 272,000 input tokens, the full request is charged at 2x input and cache rates and 1.5x output rates. Luna remains inexpensive after the multiplier, but the cliff can still invalidate a spreadsheet that prices only the tokens above the threshold.
My take: Luna is the bigger strategic release. At $0.10/$0.50, it makes classification, extraction, routing, test generation, and parallel subagent work cheap enough to reconsider architectures built around older small models. Sol is the safer default when coding judgment and multi-step tool use determine success. Start with Luna, escalate failed or ambiguous work to Sol, and keep Astra for the tasks where its additional capability wins an evaluation. Our GPT-6 Sol guide, GPT-6 Luna guide, and Sol vs Luna comparison cover the full pricing and routing decision.
2. Claude Opus 5.5 makes the premium tier less premium
Anthropic launched Claude Opus 5.5 on September 22 with the API ID claude-opus-5-5. The model has a 1M-token context window, 128K maximum output, and always-on adaptive thinking. It is available through the Claude API and across AWS, Google Cloud, and Microsoft platforms.
Standard pricing is $4 per million input tokens and $20 per million output tokens, down from $5/$25 for Opus 5. Cache reads fall more sharply, from $0.50 to $0.20 per million tokens. Anthropic says the combination of lower rates and lower token use reduces typical workload cost by 40%, while output generation is more than 30% faster. Those are vendor measurements, not a guarantee for every workload.
The launch announcement reports strong agentic coding results, including 66.4% on Terminal-Bench 4.0 at xhigh effort and 54.4% on FrontierCode 1.1 Main at max effort. The comparison is not perfectly uniform: models use different harnesses and effort settings, and some Anthropic safeguards reroute restricted tasks to fallback models. Anthropic itself warns that small benchmark margins have become less reliable guides to real-world differences.
Migration has a behavioral constraint beyond price. Opus 5.5 uses preserved thinking for newer API accounts, so applications must return prior thinking blocks without modifying them. Cybersecurity and biology safeguards can also route certain work away from Opus 5.5. Zero-data-retention access remains available, which differs from Fable 5.1’s default retention posture.
My take: Opus 5.5 is the first Opus release I would evaluate as a default for genuinely difficult repository work rather than reserve automatically for escalation. But Sol is half the standard token price, and token rates alone still ignore how many attempts a task needs. Run both on the same migrations, incidents, and code reviews, then compare accepted results and review time. The Opus 5.5 guide and GPT-6 Sol vs Opus 5.5 comparison contain the migration and pricing details.
3. Grok 4.7 becomes a credible price-performance wildcard
SpaceXAI released Grok 4.7 on September 21 for coding, agentic tasks, and knowledge work. The public API model ID is grok-4.7. It accepts text and images, has a 500,000-token context window, and supports low, medium, high, and xhigh reasoning. High is the default.
At standard rates below 200K prompt tokens, pricing is $2 per million input tokens, $0.50 cached input, and $6 output. Prompts above 200K double all three rates for the request. The fast variant costs twice as much but is documented only for Cursor and Grok Build, not the public xAI API.
The official model documentation contains two practical integration details:
- set
prompt_cache_keyon Responses requests, orx-grok-conv-idwith Chat Completions, to keep a conversation on the same server and improve cache hits; - pass returned encrypted reasoning items back unchanged in later Responses calls so multi-turn reasoning continues correctly.
SpaceXAI reports sizeable improvements over Grok 4.6 on CursorBench, Terminal-Bench, engineering, legal, and office-work evaluations. Those numbers come from the model vendor. They make Grok 4.7 worth testing, not a universal winner.
My take: Grok 4.7 occupies an interesting middle position. Its output is cheaper than Sol while its cached input is more expensive, so the workload’s input-to-output ratio matters. The explicit cache-routing requirement is also an operational tax that a superficial price table hides. Test long tool loops with and without stable cache keys and verify that your framework preserves encrypted reasoning items. See the Grok 4.7 complete guide for API and long-context details.
4. Copilot adds the missing runtime controls: containment and traces
GitHub released local sandboxing in the Copilot app on September 23 as a public preview. Each project can restrict filesystem reads and writes, outbound internet and local-network access, plus Git and GitHub CLI credentials for local repository sessions.
The sandbox announcement has four boundaries worth noting:
- sandboxing is off by default;
- project defaults apply only to new sessions;
- changed policies require a new or restarted session;
- Copilot app, CLI, cloud, and remote-host sandboxes are separate configurations.
The fail-closed behavior is the most important detail. If the operating system cannot enforce the requested policy, the shell fails rather than silently running without a sandbox. Enterprise-managed settings can still make the effective policy stricter than the project requests.
One day earlier, GitHub added OpenTelemetry export through enterprise-managed settings. Teams can send traces of model and tool activity to compatible monitoring systems. Prompt and response content is excluded by default, so useful content capture is an explicit privacy decision rather than an accidental default.
My take: These features belong together. A sandbox limits what an agent can reach; telemetry shows what it attempted and where a session failed. Neither proves that a change is correct. Enable sandboxing on a disposable repository, test denied paths and network destinations with canaries, then inspect the exported spans before rolling it out. Our Copilot app guide covers the broader client boundaries, while AI agent logging and tracing explains what to capture without leaking sensitive content.
Quick hits
- Models land in Copilot: GPT-6 Sol, GPT-6 Luna, Claude Opus 5.5, and Grok 4.7 all became available in GitHub Copilot this week. Availability in a model picker is not proof of identical pricing, context limits, tools, or reasoning controls versus the direct APIs.
- VS Code 1.138 agent updates: Local Dev Containers are rolling out in the Agents window, sessions can be marked done after their pull requests merge, and pull requests can be created without leaving the window. The weekly release notes label several of these capabilities as gradual rollout or preview.
- Copilot review controls: Teams can request code reviews through additional entry points and configure review behavior more precisely. Keep branch protection and human approval requirements separate from how an automated review starts.
That’s it for this week. Next Thursday: early cost-per-accepted-task results from the new model families, whether Luna changes multi-agent economics, and what Copilot’s local sandbox blocks in practice.
Want this in your inbox? Subscribe to AI Dev Weekly.
Previous issue: AI Dev Weekly #26
FAQ
Which GPT-6 model should developers start with?
Use Luna for focused, high-volume tasks and Sol for complex coding and agent workflows. Escalate to Astra only when its higher capability improves your measured success rate enough to justify the price.
Is Claude Opus 5.5 cheaper than GPT-6 Sol?
No at standard token rates. Opus 5.5 costs $4/$20 per million input/output tokens versus Sol at $2/$10. Opus can still cost less per accepted task if it completes your workload with fewer attempts or tokens.
Is Grok 4.7 Fast available through the public xAI API?
The official documentation lists Grok 4.7 Fast for Cursor and Grok Build, not the public xAI API. The standard grok-4.7 model is available through the API.
Does Copilot local sandboxing cover every Copilot session?
No. The preview covers local repository and working-tree sessions in the Copilot app. CLI, cloud, and remote-host sessions have separate boundaries or configuration.