AI Radar Weekly #2: GPT-5.6, Grok 4.5, and the Agent Stack

This week was not just another model launch.

GPT-5.6 arrived alongside a wider change in how AI work is packaged. At the same time, Cursor and SpaceXAI released Grok 4.5, Grok Build adopted it as its coding engine, Claude Code shipped another dense week of workflow and reliability improvements, and GitHub Copilot made its desktop agent available across plans.

For solo SaaS builders and small technical teams, the useful takeaway is not “switch everything to the newest model.” It is that the coding-agent stack is separating into clearer layers:

• a high-reasoning model for difficult planning and review;
• a balanced default for routine implementation;
• a cheaper worker for bounded tasks;
• and an agent harness that controls tools, approvals, sessions, costs, and recovery.

That is a more practical way to evaluate this week than any single benchmark.

In this recap

• GPT-5.6 becomes a model family, not one default
• Grok 4.5 puts Cursor and Grok Build in the frontier race
• ChatGPT Work pushes Codex beyond coding
• Copilot becomes an agent control surface
• Codex, Claude Code, and open harnesses improve the operator layer
• What to test next

What happened

1. GPT-5.6 becomes a model family, not one default

OpenAI introduced GPT-5.6 on July 9. GitHub then began rolling out three GPT-5.6 variants in Copilot:

• Sol for the highest reasoning ceiling and demanding, long-running agent work;
• Terra as the balanced option for everyday interactive and agentic coding;
• Luna as the lightweight, lower-cost option for smaller and faster tasks.

GitHub says Sol is available to Copilot Pro+, Max, Business, and Enterprise plans. Terra and Luna cover Pro through Enterprise. Business and Enterprise administrators must enable the model policy before their teams can select the new models, and the rollout is gradual.

That packaging matters. Builders have spent the past year choosing one “best” model and routing nearly every task through it. A three-tier family encourages a better operating pattern:

1. Send architecture, ambiguous debugging, and final review to the strongest model.
2. Keep normal feature work on the balanced model.
3. Route mechanical edits, extraction, formatting, and other bounded work to the cheaper model.

The model picker is becoming a workload router.

This does not automatically lower cost. GitHub bills the GPT-5.6 models at provider list pricing under usage-based billing, and Codex now warns when Ultra reasoning is combined with high multi-agent concurrency. The savings only appear when the harness and the operator assign work deliberately.

2. Grok 4.5 puts Cursor and Grok Build in the frontier race

Cursor and SpaceXAI released Grok 4.5 on July 8. This was not a routine model-picker addition. Cursor says the mixture-of-experts model was trained jointly with SpaceXAI using trillions of tokens of Cursor data, including developer interactions with codebases and software tools, plus broader STEM and knowledge-work data.

The release matters across three surfaces:

• Cursor: Grok 4.5 is available across desktop, web, iOS, CLI, and the Cursor SDK. Cursor lists base pricing at $2 per million input tokens and $6 per million output tokens, with a faster variant at $4 and $18.
• Grok Build: SpaceXAI's coding agent now uses Grok 4.5 and supports an interactive fullscreen terminal interface, headless scripts, bots, and Agent Client Protocol integrations.
• xAI API: builders can use the same grok-4.5 model directly in their own agent loops and IDE integrations.

Cursor also disclosed an important benchmark limitation: an earlier snapshot of the Cursor codebase was accidentally included in training, so Cursor excluded its CursorBench result while it updates the benchmark. That kind of caveat matters more than a clean leaderboard screenshot.

The practical implication is that Grok Build is no longer a side note. It is a real terminal-agent competitor, and Grok 4.5 is a credible candidate for long-running software and tool-use tasks. Builders should still evaluate it on their own repositories before replacing a proven default.

3. ChatGPT Work pushes Codex beyond coding

OpenAI also introduced ChatGPT Work, an agent mode designed to gather information across connected apps and produce finished artifacts such as documents, spreadsheets, slides, and web apps.

The important details for operators are:

• Work can break a complex project into smaller steps and continue for hours.
• Scheduled Tasks can run once, on a recurring schedule, or when an event occurs.
• Connected plugins can supply context from tools such as Google Drive, Slack, Microsoft Teams, email, calendars, and project trackers.
• Users can follow progress, answer questions, steer the task, and approve important actions.
• The Codex app is merging into the ChatGPT desktop app, while Codex remains available as the coding workflow inside that broader surface.

OpenAI says more than five million people use Codex each week, with more than one million using it for work outside software development. Whether or not those usage numbers change your tool choice, the product direction is clear: Codex technology is becoming a general work engine, not only a repository editor.

For a founder, the practical question is where the workflow should live.

ChatGPT Work may be the easiest surface for app-connected documents and recurring knowledge work. A terminal-first setup such as Codex on a VPS remains attractive when the job depends on repositories, scripts, repeatable checks, source control, and explicit deployment receipts. The two approaches can coexist, but they should not silently own the same scheduled task.

4. Copilot becomes an agent control surface

GitHub shipped several connected changes this week.

The GitHub Copilot app is now available on macOS, Windows, and Linux across every Copilot plan, including Free and GitHub Education. It also supports bring-your-own-key sessions without a Copilot subscription.

In Visual Studio Code, GitHub highlighted:

• parallel agent sessions and multiple chats inside a session;
• generally available browser tools for navigation, screenshots, and web-app validation;
• session-level and subagent cost visibility;
• Marketplace model-provider discovery;
• larger context windows for compatible models;
• stronger Autopilot completion behavior;
• session sync and searchable coding history.

JetBrains users also gained Codex as an agent provider in public preview. After installing Codex CLI, a developer can select Codex from the Copilot agent picker without leaving the IDE. GitHub added hooks, MCP server management, permission-level controls, and AI-assisted scaffolding for instruction, prompt, skill, agent, and hook files.

There is a larger pattern behind these individual features. The editor is no longer only where a model suggests code. It is becoming the place where an operator chooses the agent, model, permissions, tools, parallel workstreams, and review path.

GitHub also made Kimi K2.7 Code generally available in Copilot and expanded it to Business and Enterprise. GitHub describes it as the first open-weight model in the Copilot model picker and positions it as a lower-cost coding option. That gives teams another worker candidate, but it belongs in an evaluation queue rather than an automatic migration.

5. Codex, Claude Code, and open harnesses improve the operator layer

The model announcement got the attention. The harness releases made it usable.

Codex CLI 0.144.0 and 0.144.1 added or improved:

• a writes approval mode that permits declared read-only actions while prompting on writes;
• interactive authentication requests for MCP tools without an experimental opt-in;
• runtime authentication support for app-server hosts;
• recovery when a resumed thread references a retired model;
• warnings for costly combinations of Ultra reasoning and high agent concurrency;
• package and code-mode installation reliability fixes.

Those are operational features. They make it easier to run a long-lived agent without treating every tool call the same or losing a thread when the model catalog changes.

Claude Code 2.1.202 through 2.1.207 also shipped meaningful operator work this week:

• configurable dynamic-workflow sizing and workflow-level OpenTelemetry attributes;
• auto mode without the earlier opt-in on Bedrock, Vertex AI, and Foundry;
• directory suggestions for /cd and a /doctor check for oversized checked-in CLAUDE.md files;
• improved /commit-push-pr handling for configured push remotes;
• fixes for headless hook streaming, invalid structured-output schemas, lost messages, terminal lag, and remote managed-setting consent.

There was no single Claude Code launch moment comparable to GPT-5.6 or Grok 4.5. The weekly release cluster still deserves coverage because it affects teams already operating Claude Code in repositories, CI, SDK, and cloud-provider environments.

Hermes Agent 0.18.1 and 0.18.2 shipped as infrastructure-focused releases. The stable tags bundled installer, updater, dashboard, gateway, MCP, provider, Docker, and WhatsApp reliability work. The release notes explicitly defer the complete feature narrative to 0.19.0, so this is a stability signal rather than a focused public feature launch.

OpenClaw 2026.7.1 beta 5 is more ambitious but still a prerelease. Its notes include GPT-5.6 support, model routing and budget reporting, conversational onboarding, session organization, crash-loop recovery, Codex steering from Telegram, and an openclaw attach path for connecting Claude Code to an existing Gateway session with temporary access. These are meaningful ideas to watch, but beta status is a reason to test them away from critical production workflows.

OpenCode 1.17.14 through 1.17.18 continued improving MCP code mode, provider routing, reasoning variants, desktop sessions, review panels, and model selection. The release cadence is useful evidence that the open-source coding-agent layer is competing on workflow quality, not only model access.

Why it matters

Model quality is becoming one input to a larger system

A founder choosing an AI coding setup now has at least five separate decisions:

1. Which model handles difficult reasoning?
2. Which model handles normal implementation?
3. Which cheap model handles bounded worker tasks?
4. Which harness owns tools, approvals, memory, and schedules?
5. Which surface makes review and recovery easiest?

Treating those as separate decisions prevents expensive overuse and makes replacements less disruptive.

Approval modes are turning into product features

Codex’s writes mode and the permission controls appearing across Copilot and other agents are not minor settings. They determine whether an agent can inspect freely, whether mutations require review, and whether a long-running task can continue without constant interruption.

For most repository work, a sensible default is still:

• read and inspect freely;
• ask before external or destructive actions;
• write only inside the scoped worktree;
• run tests automatically;
• require human approval before merge, deploy, or publication.

Browser validation is moving closer to implementation

Copilot’s generally available browser tools can navigate pages, capture screenshots, and validate web apps directly from VS Code. That closes an important gap between “the code compiled” and “the user-facing route works.”

It does not remove the need for independent review. It does make rendered-page checks easier to include in the same implementation loop.

How this fits into the AI stack

A practical builder stack after this week looks like this:

• Reasoning/review: GPT-5.6 Sol, Grok 4.5, Claude, or another measured high-reasoning model for architecture, difficult debugging, and final inspection.
• Default implementation: GPT-5.6 Terra, Grok 4.5, Claude, or a comparable balanced coding model after a repository-specific evaluation.
• Cheap workers: GPT-5.6 Luna, Kimi K2.7 Code, or another measured low-cost model for narrow tasks.
• Coding harness: Codex CLI, Grok Build, Claude Code, Cursor, Copilot, or OpenCode based on the repository and operator experience you want.
• Always-on orchestration: Hermes Agent or OpenClaw when work must run on schedules, persist across channels, or coordinate multiple tools.
• Verification: tests, diffs, CI, browser checks, preview deployments, and explicit approval before public side effects.

The useful advantage is not access to every tool. It is having a clear owner for each layer.

If you are building that system from scratch, start with Codex CLI on a VPS, compare Codex vs Claude Code, and then add the durable context layer described in How to Build a Living AI Brain.

What builders should test next

1. Run one three-tier routing experiment

Choose a real feature slice. Give planning and review to the strongest model, implementation to the balanced model, and one mechanical subtask to the cheap worker. If Grok 4.5 is available in your current stack, include it as a separate candidate rather than assuming either the launch benchmarks or the Cursor training advantage will predict your result. Record:

• total cost or credits;
• elapsed time;
• intervention count;
• test failures;
• review findings;
• whether the cheap worker’s output survived final review.

One measured task is more useful than a week of model-picker speculation.

2. Test the approval boundary

If you use Codex 0.144, try the new writes mode in a disposable worktree. Confirm which read actions proceed, which writes pause, and whether the prompts are clear enough for your actual workflow.

3. Add rendered-page proof to one coding-agent task

Use the browser tooling available in your stack to validate the exact changed route at desktop and mobile width. Check the visible heading, primary action, broken images, and obvious overflow. Keep CI and browser proof as separate receipts.

4. Keep prereleases in a test lane

OpenClaw’s beta contains several ideas worth studying, especially routing, recovery, and external harness attachment. Do not confuse an interesting prerelease with a stable upgrade recommendation. Test it against a non-critical workflow and record where it recovers cleanly—or does not.

What to watch next

• Whether GPT-5.6 routing produces measurable cost and quality gains in real repository work.
• Whether Grok 4.5 and Grok Build hold up on unfamiliar repositories, especially outside Cursor's own training distribution.
• Whether Claude Code's workflow sizing, telemetry, auto mode, and reliability fixes reduce operator intervention in long-running tasks.
• How ChatGPT Work and the merged desktop app divide responsibilities between connected business workflows and Codex repository tasks.
• Whether Copilot’s app and browser tools reduce the gap between implementation and visual verification.
• Hermes Agent 0.19.0 for the complete explanation of the changes bundled into the July stable releases.
• A stable OpenClaw 2026.7.1 release before treating its new orchestration features as production-ready.
• Independent Kimi K2.7 Code results on bounded worker tasks.

Bottom line

The most important change this week was not that GPT-5.6 or Grok 4.5 scored higher. It was that competing model providers, coding agents, editors, and open harnesses all moved toward longer-running work with more explicit routing, permissions, telemetry, and recovery.

For builders, the winning workflow is increasingly explicit: route by task difficulty, keep mutations scoped, measure cost at the session level, validate the rendered result, and preserve a human decision before anything public ships.

That is how a new model becomes a better operating system instead of a more expensive default. It is also why a useful radar has to track the whole field, even when the operator has a preferred stack.

Always-On Agents preorder

Build an agent that keeps working after you close your laptop.

Start with the free setup checklist. It helps you avoid the usual traps: no place for state, secrets mixed with prompts, automations that send before you approve them, and logs you cannot debug later.

• VPS, Codex, Hermes, and Discord setup steps
• Approval gates before email, tickets, or posts change
• Reusable skills, scripts, and operating checklists
• A preorder path if you want the full walkthrough

Get the free setup checklistReserve preorder — 50% offRead the full public series

Primary sources

• OpenAI: ChatGPT is now a partner for your most ambitious work
• Cursor: Introducing Grok 4.5
• SpaceXAI: Grok Build
• SpaceXAI: Grok Build documentation
• Claude Code releases
• GitHub: GPT-5.6 Sol, Terra, and Luna in Copilot
• GitHub: Copilot in Visual Studio Code, June 2026 releases
• GitHub: Copilot app available to all
• GitHub: Codex as an agent provider in JetBrains
• GitHub: Kimi K2.7 Code for Copilot Business and Enterprise
• Codex CLI 0.144.0 release notes
• Codex CLI 0.144.1 release notes
• Hermes Agent 0.18.1 release notes
• Hermes Agent 0.18.2 release notes
• OpenClaw 2026.7.1 beta 5 release notes
• OpenCode changelog