Claude Cowork arrived on mobile and web on July 7, 2026, and the shift is bigger than another app icon. Anthropic turned Cowork into a background AI agent that runs on their cloud, keeps working when the laptop is closed, and syncs status to a phone or a browser. For mobile teams, n8n automations, and multi-agent orchestrators, that changes where long tasks live and how the phone signals progress.
The July 7, 2026 AINews / smol.ai newsletter flagged the launch as one of the week's three anchor moves in agent orchestration, alongside new harness benchmarks and Google's Managed Agents beta. Anthropic's own numbers say more than 90% of Cowork activity is non-coding: business operations, content, spreadsheets, decks. The interesting story for mobile automation teams is not the model. It is what the surface tells you about how background agents should be wired into a real product.
The 30-Second Version
What Actually Shipped on July 7, 2026
The desktop app launched in January 2026. The July 7 release adds mobile and web clients and, more importantly, a cloud runtime that decouples the task from the device. Three things ship together, and each one changes a different part of the automation stack.
| Change | What it does | Impact on mobile and automation teams |
|---|---|---|
| Mobile and web clients | iOS, Android, and browser access for Claude Max seats | The same background task can be started, checked, and approved from any device |
| Cloud-hosted background execution | Tasks run on Anthropic infrastructure, not the user device | Long agent runs stop being tied to a foreground app or an unlocked screen |
| Cross-device task handoff | Start on desktop, check on phone, approve on web | Product flows can move the human touch point to wherever it is cheapest |
| Human-in-the-loop prompts | The agent stops to ask when only the user can decide | Notification design becomes a first-class part of the automation flow |
Why Background Agents Matter for Mobile
Mobile apps live under three constraints that a server does not have: short foreground time, tight battery budgets, and users who read every stall as a broken screen. A background agent on someone else's cloud removes one of those constraints entirely and reshapes the other two.
- The phone stops hosting the work. The agent runs on Anthropic's cloud, so a five-minute plan-execute-review loop no longer needs a foreground app or a background task extension.
- Notifications become the UI. Status updates arrive as push, deep-link into a review screen, and let the user approve or redirect with one tap. This is the interaction shape the mobile app should mimic for its own agents.
- Battery cost drops to near zero. The device pays for a socket and a few pushes, not tokens and tool calls. That fits low-power modes, iOS background limits, and long-tail user sessions.
- Handoff replaces context switching. A user can start a task on the laptop, get a phone ping in a meeting, and finalize on web after lunch. The agent state is the anchor, not the device.
The right question for mobile teams in July 2026 is not "should we build our own agent app". It is "which of our long-running tasks belong on a cloud-hosted agent that our mobile client just observes".
How Cross-Device Orchestration Actually Works
Cowork's surface is small but the pattern underneath is worth stealing. There is one durable task, many client views of it, and a policy for when the human is pulled back in. Copying that shape into a Halmob-style mobile plus n8n stack is where the product win lives.
The three components you actually need
- A durable task store. Every task has an id, a state, a plan, a log, and a set of pending decisions. This is the object every device queries.
- A runner that survives disconnects. The agent loop should not care whether a client is connected. It runs, it pauses on human input, it writes to the store.
- A notification and deep-link layer. Push and email carry the state change to the user. The link opens the exact screen where the decision lives, not a generic inbox.
What Cowork gets right that your stack should copy
- The agent asks for input only when it must. Silent progress is fine; every ping should mean a real decision.
- The user picks the device, not the vendor. A phone ping should let the user finish on the browser without losing context.
- The task is the first-class object. Chats, prompts, and tools are properties of the task, not the other way around.
Wiring Cowork-Style Patterns Into n8n
For n8n workflows, the July 7 launch is a design cue more than a new integration. Most useful automations are already long-running, and most of them still assume a synchronous caller. Moving them toward a background-agent shape is a small refactor with a large UX payoff.
Step 1: Give every workflow a task id and a state row
Add a first step that creates or updates a row in a task table with a stable id, a status, and a pointer to the current step. Every downstream node writes back to that row. This is what lets a phone or a browser observe the same run.
Step 2: Split each workflow into safe pauses
Break the workflow at points where a human might need to decide. Use n8n's wait node or a webhook trigger so the workflow can park itself, notify the user, and resume when the answer arrives. The agent should be able to sleep for an hour without holding a runner slot.
Step 3: Push the state change, do not push the content
A good notification carries a task id, a short reason, and a deep link. The client fetches the full detail when the user opens it. This keeps push payloads small, works with expo, apns, and fcm, and avoids stale content in the notification tray.
Step 4: Give every task a single review screen
On the mobile app and on the web, one screen shows the plan, the log, the pending decision, and the approve or redirect actions. That screen is the product surface. The agent, the workflow, and the model are implementation detail behind it.
Do Not Ship Silent Background Agents
What to Watch Before You Build On Top of Cowork
Mobile and web Cowork is a preview shipping to Claude Max first, and access widens over "the coming weeks". That gives teams a short window to design the boundary between what they use Cowork for and what they own themselves.
- Access shape. Max first, other plans later. A team that wants Cowork inside a client-facing product should not assume general availability yet.
- Where the data lives. Cowork tasks run on Anthropic's cloud. That is fine for content and ops work; it is a review point for regulated data.
- Notification budget. Push channels are cheap until they are noisy. Design a per-user cap and a digest fallback before you turn on background alerts.
- Audit trail. Every state change should log the agent action, the user decision, and the model that answered. That is the cheapest way to explain the run in three months.
Where This Fits in the Halmob Stack
At Halmob, the same three-layer picture shows up on almost every engagement: 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. Claude Cowork on mobile and web does not replace that stack. It gives it a working template for the piece most teams underbuild: the durable task, the cross-device handoff, and the human-in-the-loop prompt.
The operating patterns we described in the Hermes Workspace mobile agent orchestration guide and the executor and advisor pattern for agent orchestration map directly onto a Cowork-shaped runtime: one planner, one executor, one review point, and a client that just observes. Pair that with the routing model from our model routing layer for mobile AI agents and n8n flows and the credit-based cost story from the Claude Fable 5 return guide. The through-line is the same: the agent is one layer, and the pipeline around it is the durable product.
For teams that already run automation on n8n on AWS ECS Fargate, the background-agent shape sits naturally on top of the same task table, the same retry policy, and the same push channel. The point is not to run more agents. It is to move the ones you already have off the phone and behind a single review screen.
The Bottom Line
Claude Cowork on mobile and web is a preview, but the pattern is not. Background agents that run on someone else's cloud, sync state across devices, and pull the user in only for decisions are the shape most mobile automation should be moving toward. For teams working on mobile plus n8n plus agent orchestration, the practical action this week is small and specific: pick one long-running workflow, give it a task id, split it at the first human decision, and send the phone a deep link instead of a payload. Do that once and the rest of the pattern falls out.
For source material, start with the Anthropic Cowork on web and mobile announcement, the Claude API and Agent SDK docs, and the smol.ai AINews newsletter for the wider July 2026 agent-orchestration context. For teams that want this pattern inside a real mobile and automation product, Halmob can design the task store, the notification layer, and the review screen that make background agents safe to ship.