On July 9, 2026, OpenAI shipped three things at once that matter for mobile and automation teams: the GPT-5.6 model family (Sol, Terra, Luna), ChatGPT Work as a long-running agent on web and mobile, and multi-agent orchestration in the Responses API (beta) with programmatic tool calling. Together they turn the mobile-plus-n8n stack into something new: a shipping surface for agents that keep working after the app is backgrounded.
The July 2026 AINews / smol.ai newsletter covered the wave in one issue for a reason. Each piece on its own is a normal release note. Stacked, they change what a mobile agent stack can commit to: a root planner on GPT-5.6 Sol coordinating subagents through the Responses API, executing tools programmatically inside a single reasoning turn, and rolling out to Pro, Enterprise, and Edu on both web and the ChatGPT mobile app with Plus and Business landing days later.
The 30-Second Version
What Actually Shipped on July 9, 2026
Three pieces landed in a single wave, and the interesting part is how they compose. Treating them as separate announcements misses the shape.
| Piece | What it is | Why mobile and automation teams care |
|---|---|---|
| GPT-5.6 Sol / Terra / Luna | Three-tier model family with tiered pricing ($5/$30, $2.5/$15, $1/$6 per M tokens) and 90% cache-read discount | A cheap tier that can plan on a phone budget and a top tier that can hold a long orchestration loop |
| ChatGPT Work | A long-running work agent on web and the ChatGPT mobile app, with connected apps, a browser, Computer Use, and Scheduled Tasks | The first shipped OpenAI agent that stays on a task for hours from a phone, not just answers a message |
| Multi-agent orchestration (Responses API beta) | A root model creates and coordinates subagents inside a single Responses call, with persisted reasoning and max reasoning effort controls | The orchestrator stops living in your n8n graph and starts living inside one API call, which changes latency, cost, and audit shape |
| Programmatic tool calling | The model writes and runs programs in-memory that coordinate tools and process intermediate results, ZDR-compatible | Removes a class of round trips for tool-heavy mobile flows; the plan-and-glue code runs where the model already is |
Why ChatGPT Work Changes the Mobile Agent Shape
Every mobile agent product until now has had the same architecture problem: the planner and the loop have to live somewhere the phone cannot reliably host. The app gets suspended, the network flakes, the battery tab kills the process. Teams have worked around it with server-side orchestrators, background jobs, or n8n flows triggered by webhooks. ChatGPT Work does not remove that pattern. It productizes the server-side half of it and puts the phone in the passenger seat where it belongs.
- The phone becomes an execution and notification surface. The plan lives with the agent. The phone shows progress, accepts approvals for risky actions, and returns the finished artifact. This is closer to email than to chat.
- Scheduled Tasks turn recurring work into a first-class primitive. The Friday report, the Monday standup pull, the overnight lead enrichment: the same shape as an n8n cron trigger, now sitting inside the assistant your team already uses.
- Computer Use plus a built-in browser closes the tool gap for consumer apps. Any app with a web surface is reachable without a first-party integration, which is the same wager Microsoft made with Scout and Apple made with Poke.
- Codex-powered editing sits inside the same product. The document, spreadsheet, or Site the agent produces can be reviewed and edited by the same agent in the same session. No handoff to a second tool.
The mobile agent question stops being "can the phone run the plan?" and starts being "does the plan need the phone at all, and if so, for what?".
Multi-Agent Orchestration in the Responses API, Explained
The Responses API beta adds a specific capability: a root call spawns subagents that can run in parallel or in sequence, with their own tools and reasoning budgets, and the root aggregates. Persisted reasoning means intermediate thought is carried across turns without being re-derived, and max reasoning effort caps how much time any given subagent can spend before it returns.
For teams that already ship the executor-plus-advisor pattern in n8n or a custom harness, the practical question is where to keep the loop.
| Layer | Before July 9 | After July 9 | Recommendation |
|---|---|---|---|
| Root planner | n8n workflow node calling GPT / Claude / Gemini | Responses API root call with multi-agent enabled | Move the planner into the Responses call for tool-heavy flows; keep n8n for the outer trigger and observability |
| Subagent fan-out | Custom code splitting work across LLM calls | Root model creates subagents natively | Delete the custom fan-out code for stateless subtasks; keep it where you need cross-request memory |
| Tool calling | One tool call per model turn, round-tripped | Programmatic tool calling runs multi-step logic in one turn | Move deterministic tool sequences into programmatic calling; keep round-tripped tools where a human needs to approve mid-plan |
| Reasoning persistence | Stored in your own vector store or database | Persisted reasoning across turns in the API | Use API persistence for short and medium loops; keep your store for anything that needs to survive weeks |
| Audit trail | n8n execution log plus your own trace | Responses API traces plus your outer trace | Keep the outer trace; the API trace is not a substitute for product-level analytics |
For deeper context on how a routing layer and executor / advisor split hold up when subagents multiply, see the executor and advisor pattern for agent orchestration and the model routing layer for mobile AI agents and n8n flows. The move here is not to throw those patterns out. It is to notice that the Responses API now owns one layer of the stack that used to be your code.
How to Slot ChatGPT Work Into an n8n Automation Stack
A mobile app plus an n8n automation layer plus an agent already works. ChatGPT Work does not replace that stack. It replaces one node in it, and it does that well only for a specific shape of task.
Step 1: Pick a task with a long tail, not a short one
ChatGPT Work is designed for hours-long projects with intermediate artifacts. A one-shot data lookup or a single form submission is the wrong shape. Weekly reports, lead enrichment across a large list, or multi-day research briefs are the right shape.
Step 2: Draw the boundary between the agent and your n8n flow
Keep n8n as the outer trigger, the event router, and the audit surface. Let ChatGPT Work own the planning-and-authoring inner loop. This is boring. It is testable. And it means when either side has an outage, the other side still logs.
Step 3: Move the human approval into the agent, not out of it
Sensitive actions can pause and request approval inside ChatGPT Work. A previous pattern was pausing an n8n flow and pinging Slack. That still works, but if the action is inside the agent's workspace, the approval should be too. Otherwise you split state.
Step 4: Route the model per call, per tier
The three-tier pricing changes the routing math. Luna at $1 / $6 per million tokens is a real fallback for free-tier mobile flows. Sol at $5 / $30 is what the orchestrator wants when a plan has to survive fifty tool calls. Terra sits in the middle and is where most Scheduled Tasks land. The routing rule to draw is explicit and testable, in the shape covered in the model routing layer guide.
The Responses API Beta Is Beta
How ChatGPT Work Compares to Claude Cowork and Workspace Agents
Three products now serve the "long-running mobile agent" slot: OpenAI's ChatGPT Work, Anthropic's Claude Cowork, and the earlier ChatGPT Workspace Agents that shipped in April 2026. The distinctions matter.
| Feature | ChatGPT Work (Jul 2026) | Claude Cowork | ChatGPT Workspace Agents (Apr 2026) |
|---|---|---|---|
| Primary unit | A long-running work task on web and mobile | A background agent that runs on mobile and web with the same session | A shared, always-on team agent |
| Underlying model | GPT-5.6 (Sol / Terra / Luna) plus Codex | Claude Fable 5 / Sonnet 5 depending on tier | Codex family |
| Scheduling | Yes, first-class Scheduled Tasks | Yes, background schedules with mobile catch-up | Limited, per-agent |
| Computer Use | Yes, built-in browser plus Computer Use | Yes, on both mobile and desktop | Limited |
| Multi-agent orchestration | Yes, via Responses API (beta) | Yes, at the harness level | No native orchestration primitive |
| Best for | Individual pros running long tasks from a phone | Teams that want the same agent on mobile and web with strong review | Teams that want a shared, always-on assistant with permissions and analytics |
For a fuller picture of the mobile-plus-background pattern, see the Claude Cowork mobile and web background agents guide and the earlier ChatGPT Workspace Agents guide. The point is not that one product wins. The point is that the mobile-agent slot is now contested by three different shapes at once, and picking wrong locks a team into the wrong stack for a year.
What to Log Before You Trust This In Production
A long-running agent plus a beta orchestration API plus a mobile execution surface adds three new places where silent failures can hide. Five pieces of telemetry make the difference between a stack that ships and a stack that gets rolled back.
- Model of record per subagent. Sol, Terra, and Luna behave differently on tool sequences. Log which tier answered each subagent call, not just the root request.
- Tool sequence per plan. Programmatic tool calling collapses multiple tool calls into one turn. Record what actually ran and in what order, or a regression is invisible.
- Approval latency. How long a human took to approve a risky action from a mobile push. This is the number that predicts whether Scheduled Tasks are useful or annoying.
- Cost per successful outcome. Not cost per API call. Cost per plan that produced a real artifact a user kept. This is the number that decides whether Sol pays for itself over Terra on a given flow.
- Reasoning persistence hit rate. Persisted reasoning is only useful if it is actually re-used. If your traces show it being regenerated every turn, the API-level persistence is not doing what you assumed.
Where This Fits in the Halmob Stack
At Halmob, the shape of every engagement is the same three layers: a mobile app that has to feel instant, an n8n automation layer that does the real work, and an agent that keeps the two honest. ChatGPT Work and multi-agent orchestration in the Responses API do not change that shape. They change what belongs in which layer.
The mobile app gets to shrink: fewer local plans, more push-notification-driven approvals, more Scheduled Tasks visible to the user. The n8n layer stays as the outer trigger and audit surface, and gets to delete some of its planner code. The agent layer moves into the Responses API for orchestration-heavy flows, and stays in n8n or a custom harness where reasoning has to survive weeks or where a human has to sit in the middle of the loop.
The operating model laid out in the Claude Fable 5 mobile agents guide and the Muse Spark 1.1 mobile multi-agent orchestration guide still applies. Move one flow at a time. Log the model tier and tool sequence per subagent. Split the orchestrator and the executor. Rebuild cost dashboards around per-outcome cost, not per-call cost. Then, and only then, expand the routing table into the beta API.
The Bottom Line
The July 9, 2026 wave is not a single product launch. It is a repositioning of where the mobile-agent loop lives. ChatGPT Work owns the long-running individual-pro task on the phone. The Responses API multi-agent beta owns the orchestration slot that used to be your code. Programmatic tool calling collapses round trips inside a single reasoning turn. The practical action for a mobile and n8n team is small and specific: pick one long-tail flow, keep n8n as the outer trigger, move the planner into the Responses API for that flow only, route between Sol, Terra, and Luna per subagent, log cost per successful outcome, and measure for two weeks before expanding.
For source material, start with the smol.ai AINews newsletter for the July 2026 agent-orchestration context, the OpenAI ChatGPT Work introduction for the product surface, and the OpenAI Responses API multi-agent guide for the API primitives. For teams that want this wired into a real mobile and automation product, Halmob can shape the routing, orchestration, and n8n integration layers that make the switch safe to ship.