Anthropic tests Claude Cowork mobile as remote control for agents

Claude Cowork on mobile is a remote control, not a hostCopy Anchor Link

Anthropic is testing desktop-like Claude Cowork multitasking for mobile, and the framing matters: your phone becomes a way to start and steer tasks that keep running on your desktop, not a new place where heavy agentic work executes locally. Early coverage describes in-app text reading "start and steer tasks directly from your phone," with screenshots suggesting a preview rather than a general release in the Bleeping Computer coverage.

That distinction decides whether the feature is useful to you. If you expect full local file access and script execution on iOS or Android, you will be disappointed. If you want to kick off a long document build at your desk and then monitor, nudge, or approve the next step from the train, the tested model fits.

Claude Code remains the coding-focused agent surface, while Cowork is positioned around broader knowledge work such as files, documents, and long-running operations, a separation reflected in the Claude Code overview. Mobile Cowork, as tested, extends that orchestration idea across devices.

What Cowork is and how mobile changes itCopy Anchor Link

On desktop, Cowork runs as a persistent layer with access to the folders you explicitly share. Compute, storage, and file operations stay on the host machine, inside a desktop app tuned for review and approval flows.

The mobile test build flips the phone into a live status console:

• Start a task from your phone against your desktop session.
• Watch progress, logs, and intermediate outputs remotely.
• Pause, add instructions, or approve a follow-up decision.
• Pick up the same state later from desktop or browser.

What it does not do, based on current coverage, is move execution onto the phone. There is no confirmed support for local agentic code execution or deep mobile filesystem access. The value is continuity: the work continues on the desktop host while you check in from elsewhere.

For teams shipping with agents, that continuity problem is familiar. Most breakage comes from lost context between sessions, not model quality. A readable repo layout helps agents resume cleanly, which is why conventions like an agent-readable repository structure matter even before you add remote control.

# Keep agent working dirs explicit so a remote steer stays safe
# desktop host:  ~/work/app (shared with Cowork)
# phone:        review + approve only, no local execution
ls ~/work/app/.agent_state 2>/dev/null || echo "no shared state file"

How long-running tasks stay alive across devicesCopy Anchor Link

The core promise in testing is background persistence: tasks keep running on the host even when you close the mobile app or walk away. You reconnect to live state rather than restarting.

Concrete patterns that fit this model:

• Start a large documentation or report generation run on desktop, then monitor sections and approve outlines from your phone.
• Launch a storage or dataset triage job that scans shared folders on the host, then review candidate files for cleanup remotely before anything is deleted.
• Queue spreadsheet reconciliation or recurring reporting work in the morning and check intermediate results between meetings.

The phone never needs the dataset. It needs progress markers, diffs, and decision prompts. That is why the tested UX centers on one-tap initiation, status pushes, and steering actions rather than editors or terminals.

This is also where production discipline matters. Background agents that run unattended need idempotency, bounded retries, and observable job state. If you run these patterns beyond demos, treat them like AI production background jobs: durable queues, explicit ownership, and logs you can audit from any device.

Starting and steering tasks from your phoneCopy Anchor Link

Based on the preview screenshots and in-app strings quoted in secondary coverage, the tested flow looks like this:

1. Open the Claude mobile app and connect to your desktop Cowork session.
2. Start a task from a workflow shortcut or a direct instruction.
3. Execution is assigned to the desktop host with its folder permissions.
4. Monitor progress bars, logs, and partial outputs on mobile.
5. Steer the run: pause, change parameters, supply missing input, or approve the next step.
6. Resume from desktop or browser with shared state intact.

Two practical rules reduce risk:

• Start permission-sensitive work from desktop first. Grant folder access deliberately on the host, then use mobile for monitoring and approvals. Mobile widens reach; it should not widen scope.
• Use mobile as mission control for decisions, not bulk editing. Approving which files to archive is safe remote work. Rewriting pipelines from a small screen invites mistakes.

If you are turning prototypes into shippable systems, pair this with a launch checklist that covers env scoping, review gates, and rollback, such as the ship AI MVP to production checklist. Remote steering amplifies speed; checklists keep that speed reversible.

What this means for developers and knowledge workersCopy Anchor Link

The tested mobile surface removes the single-screen bottleneck without claiming the phone can host everything. Benefits that follow directly from the remote-control model:

• Check long document, analytics, or file-triage runs during downtime without remote-desktop friction.
• Keep one task state across phone, browser, and desktop instead of three divergent copies.
• Respond faster when a host-side job needs a human decision, such as which artifacts to keep after a cleanup scan.
• Step in and out without penalty, because persistence lives on the host rather than in the mobile app foreground state.

Just as important is what does not change. Security boundaries are still managed on desktop. File grants, tool permissions, and integration tokens remain host-side settings. Mobile monitoring does not replace least-privilege scoping; it makes timely review possible.

For developers juggling React Native builds, docs pipelines, or data jobs, a useful mental model is terminal-plus-approvals: heavy I/O stays pinned to the machine with disk and credentials, while judgment calls travel with you.

Status, limits, and what to watch nextCopy Anchor Link

As covered, this is pre-release behavior described as testing, not a confirmed general launch. Treat availability specifics, platform coverage, and any macOS or Windows caveats as unconfirmed until Anthropic documents them on an official channel. Do not plan a rollout around screenshots.

What to track before adopting it for real work:

• Official availability and enrollment: public beta versus private test, and which plans qualify.
• Permission model: whether mobile can request new folder grants or only operate inside desktop-approved scope.
• Notification semantics: which events push to mobile, and whether approvals expire or queue.
• Audit trail: whether remote steers are logged distinctly from desktop actions.

Until those are documented, the safe adoption path is narrow: one host, a small set of shared folders, reversible tasks only, and a second reviewer for destructive operations. Expand scope only after the official docs confirm the controls.

If you want the upside now without waiting on a launch date, invest in the parts that transfer regardless: explicit task state, narrow folder grants, and checklists that make remote approvals boring. When the mobile surface reaches you, it will plug into a workflow that already survives device switches.

Ready to make your repo agent-steerable from anywhere? Start from production-grade scaffolding at OTF templates and keep folder grants tight so remote control stays safe.

SourcesCopy Anchor Link

• BleepingComputer, "Anthropic is testing desktop-like Claude Cowork for mobile" — pre-release screenshots, "start and steer tasks directly from your phone" string, work-continues framing. https://www.bleepingcomputer.com/news/artificial-intelligence/anthropic-is-testing-desktop-like-claude-cowork-for-mobile/
• Claude Code overview — Claude Code versus Cowork positioning baseline. https://code.claude.com/docs/en/overview