# A deep dive into Claude Duet

> Claude Duet is Anthropic's proactive cloud agent. Learn how it works, what it can access, and how it compares with Grok Bot and ChatGPT dots.

Author: [Flavio Copes](https://flaviocopes.com/about/) | Published: 2026-10-22 | Topics: [AI](https://flaviocopes.com/tags/ai/) | Canonical: https://flaviocopes.com/claude-duet/

Claude Duet is an agent that checks your connected apps, prepares work, and comes back when it needs a decision. You can hand it a job from your phone and leave it running on its own cloud computer.

Anthropic [announced Duet](https://claude.com/resources/articles/claude-duet) on October 21, 2026. It joins a category that already includes [Grok Bot](https://flaviocopes.com/grok-bot/) and [ChatGPT dots](https://flaviocopes.com/openai-dots/): agents you give ongoing work to, with access to the tools where that work happens.

I haven't tested Duet. This guide uses the official product pages and documentation available on October 22, 2026. The Duet examples below are workflows I would try, and the comparisons concern documented behavior. I can't tell you which one finishes a job more reliably without running the same jobs through them.

Duet's pitch is easy to understand if you run a small business. You have unanswered emails, a calendar, documents, and work waiting on other people. Keeping track of all that takes time before you even start doing the work.

An agent that prepares a useful answer before you remember to ask could help. I'd want to know what it read, how it decided something was urgent, and what it can change before connecting it to my business.

## What Claude Duet does

The [product page](https://claude.com/product/claude-duet) describes a morning brief, follow-ups during the day, and larger tasks such as preparing dashboards or decks. Duet carries over your Claude memory, skills, and connected apps. It uses Opus and chooses how much effort a task needs.

You use a separate iOS or Android app, or access it through claude.ai. Its virtual machine keeps working when your devices are off. Anthropic says it checks connected accounts every few hours, so an urgent message can arrive between checks. This is background assistance with a checking interval, rather than a guarantee that every new event gets an immediate response.

Picture a consultant preparing for a client meeting. The meeting is on the calendar, the client's last email contains an unanswered question, and a document has the latest proposal. A useful brief would bring those together and identify what the consultant needs to settle before the call.

Summarizing each source separately would leave much of the work to the consultant. The value comes from recognizing that the unanswered question changes what should happen in the meeting.

That is also where mistakes become harder to spot. A polished brief can omit the email that changes everything. I'd ask for source links beside each proposed decision.

## Getting access and setting it up

At the time of writing, the research preview requires a US Claude Pro or Max account and a waitlist invitation. Team and Enterprise aren't included. Joining the list doesn't guarantee an access date. The [getting-started guide](https://support.claude.com/en/articles/17631495-get-started-with-claude-duet) covers eligibility and setup.

Use your Claude account email when joining through the product page. Once invited, follow the email's setup instructions and sign in. I'd begin with one responsibility and the minimum app access it needs.

For example, meeting preparation needs the relevant calendar and correspondence. It doesn't need permission to buy things. Connecting every available service would make the first result harder to assess because you wouldn't know which sources shaped it.

The interface separates the main conversation from Tasks and Make. Tasks tracks work and requests for input; Make holds larger outputs. Separate topic channels share memory, so treat them as ways to organize conversations, rather than private compartments. Only you can mark a task completed.

I like that last detail. An agent can produce a file and still miss what you meant. Calling the task finished should follow your review of the result.

## Give it a job you can check

Let's use one example throughout this guide: preparing for customer meetings at a small software business.

We want a short brief that catches unresolved issues before the call. The agent should prepare suggested replies and leave customer contact to us.

I'd start with this message:

```text
Prepare me for the customer meetings on my calendar tomorrow.
Use the connected calendar and the email threads for those attendees.

For each meeting, include the purpose, unanswered questions,
and anything I promised to do. Link each item to its source.

Draft replies where a reply would help. Keep them for my review.
Don't send messages, change invitations, or contact anyone.

If you can't read a source, say which one is missing.
```

This gives us something concrete to inspect. Open the calendar yourself. Pick a meeting you know well and compare the brief with its email thread. Did the agent identify the right customer? Did it mistake a suggestion for an agreed deadline?

I'd correct those errors before asking it to repeat the work.

Then I'd add preferences based on what happened. Perhaps the brief included every old support issue when I only needed unresolved ones. Perhaps it needed to distinguish a customer's requested date from a date I accepted.

These corrections are useful because they describe decisions the agent will face again. Asking for a shorter brief won't fix a misunderstanding about commitments.

If reusable instructions are new to you, my free [AI Agent Skills Course](https://flaviocopes.com/courses/ai-agent-skills/) explains how to turn a repeated process into a skill and evaluate its results.

## What happens while you are away

Here's the workflow I would ask Duet to follow for meeting preparation. The boxes describe the job, rather than Anthropic's internal architecture.

```mermaid
flowchart TD
  accTitle: Preparing a customer meeting brief with Claude Duet
  accDescr: Connected calendar and email provide context. The agent prepares a sourced brief and drafts. The user reviews a proposed message before approving it or asking for changes.
  A[Connected calendar and email] --> B[Find tomorrow's meetings]
  B --> C[Read relevant threads]
  C --> D[Prepare brief and draft replies]
  D --> E[Show sources and proposed actions]
  E --> F{Your decision}
  F -->|Revise| D
  F -->|Approve a message| G[Send the approved message]
```

A follow-up instruction could ask it to prepare this each weekday and flag only changes that affect the meeting. I'd ask it to confirm what timing it supports and what it has set up, rather than assume my message created a schedule.

The important test comes after the first successful brief. Change an appointment, cancel one, or add a correction to a thread. Does the next result reflect the current situation?

I'd also test a missing source. Disconnect the email app and ask for another brief. A useful result would identify the missing context. A brief silently assembled from old information would be a problem.

## Connected apps and the browser

Duet can work through connectors or its cloud browser. A connector gives the agent tools for a service; the browser lets it interact with a website. Anthropic advertises more than 6,000 connectors and plugins in its marketplace. That total doesn't tell you whether a particular integration supports the operation you need.

I'd check the full path for each job. Can it read the right account? Can it find attachments? Can it return a useful link? Does it have the right action for saving a draft?

The current help guide says Microsoft 365 isn't available in Duet yet, and some connectors, including Slack, have limits. Don't infer support from the logos on the landing page. Duet can't access local files or all your Claude projects. It can't modify your Claude work, make phone calls, or send texts.

That limits how I would use it with a local project. If a customer meeting needs information in a file on my Mac, I'd need to provide that context through a supported route. I wouldn't expect Duet to discover it.

The browser has another preview limitation: you can't watch it or take control. If a workflow depends on seeing a page or completing a step yourself, I'd test that path early. Browser access alone doesn't establish that the whole job will work.

## Approvals, credentials, and private information

Anthropic says Duet prepares work independently but asks before sending messages, making payments, signing documents, or deleting things. Some actions, including securities trading and transfers between accounts, remain prohibited even with approval. Its [announcement](https://claude.com/resources/articles/claude-duet) also describes restrictions on sharing sensitive information.

I'd still write the boundary into each job. For our meeting brief, that means showing the exact recipient and message before sending. A general request to help with customer meetings shouldn't leave us guessing which commitments it might make.

The credential design is worth understanding. Anthropic says Duet uses the approach described in [Claude Managed Agents](https://www.anthropic.com/engineering/claude-managed-agents): credentials remain outside the environment where generated code runs, and tools use them through controlled infrastructure.

Keeping a token out of an agent's reach reduces the risk of that token leaking. The agent can still misuse an authorized tool, so the permitted action matters too.

Anthropic also points to its [auto mode research](https://www.anthropic.com/research/claude-code-auto-mode), where classifiers review actions, and its [browser prompt-injection defenses](https://www.anthropic.com/research/prompt-injection-defenses). A malicious instruction inside an email or webpage is a different kind of input from something you asked the agent to do. These defenses try to preserve that distinction.

I wouldn't read those protections as proof that an agent can't make a mistake. For a customer reply, I'd review the recipient and the text, including any private information it pulled from another source.

Disconnecting an app stops future access, but Duet retains memory of previously learned information. Disconnecting is therefore different from deleting what it already learned. Past-chat search has its own **Search and reference chats** toggle under **Settings > Memory**.

## Buying things with Duet

Payments deserve their own explanation because a Stripe connection can mean different things.

The Stripe connector lets Duet work with your Stripe account. [Link](https://support.claude.com/en/articles/17666484-how-to-use-link-by-stripe-with-claude-duet) is Stripe's wallet for purchases. They are separate connections.

With Link, Duet proposes a purchase, you approve the spend through Link, and it pays using a one-time card scoped to the merchant and amount. A US payment method is required. Recurring Link payments aren't supported, and a merchant can still block checkout after approval.

[Shop Pay](https://support.claude.com/en/articles/17666489-how-to-use-shop-pay-with-claude-duet) has its own connection and review flow. It also uses a one-time card for the approved purchase. Connecting Shopify to manage a store doesn't connect Shop Pay to buy from one.

Suppose I wanted replacement ink for a printer. I'd expect to review the printer compatibility, quantity, merchant, shipping, and final amount. A limited-use card helps constrain payment credentials. It doesn't tell me whether the agent chose the right ink.

I covered the broader approach in [how to let an AI agent make irreversible actions safely](https://flaviocopes.com/ai-agent-irreversible-actions-safely/), including why approval should show the specific action you're authorizing.

## Claude Duet vs Grok Bot vs ChatGPT dots

All three can keep working in the cloud after you close your laptop. The useful differences are in how you organize work, inspect execution, and connect it to the rest of your setup.

This table compares the documented product designs. It isn't a performance ranking.

| Question | Claude Duet | Grok Bot | ChatGPT dots |
| --- | --- | --- | --- |
| How do I organize work? | An assistant with a main thread and topic channels | Named Bots with different roles | A dot with ongoing responsibilities and delegated tasks |
| Where does cloud work happen? | Its own VM and browser | One persistent computer shared by your Bots | Its cloud computer and separate cloud threads |
| Can I inspect and take over the browser? | Unavailable in the preview | Yes | Yes |
| What repeats the work? | Background check-ins and follow-ups | Skills and scheduled or supported event-driven routines | Follow-ups, schedules, and supported events |
| How does it relate to coding? | Can prototype and build apps | Can coordinate Cursor agents | Can create and manage Work and Codex tasks |

The sources for these differences are the [Duet guide](https://support.claude.com/en/articles/17631495-get-started-with-claude-duet), [Grok Bot overview](https://docs.x.ai/grok-bot/overview), and OpenAI's [dots task documentation](https://learn.chatgpt.com/docs/dots/tasks-and-memory).

### Grok Bot gives you explicit roles and a shared computer

You can create Bots for different jobs and have them coordinate. They share files, browser sessions, and command-line credentials on one account-level computer. Each Bot has its own screen, but those screens don't isolate access. The [computer documentation](https://docs.x.ai/grok-bot/computer-and-apps) makes that boundary explicit.

I'd use separate roles when the jobs need different instructions. A Bot checking provider pricing needs a different method from one tracking customer follow-ups. Naming them makes it easier to find and correct the relevant instructions.

I would still keep private material off that shared computer if another Bot shouldn't access it. A name like Finance Bot doesn't create a protected finance workspace.

Grok Bot's [skills and routines](https://docs.x.ai/grok-bot/skills-routines-and-automations) also make repeated work explicit. Save the successful method as a skill, then attach a schedule or supported event. That structure is useful when I want to inspect why a particular job ran.

For browser work, Grok Bot lets you watch and take over. That would weigh heavily in my choice if the workflow needed manual verification on a website.

### A dot coordinates work across ChatGPT and Codex

OpenAI documents a dot as an ongoing coordinator. It can use background agents and create separate cloud threads, including tasks in a Codex environment you've already configured. It can also work on an optionally connected personal computer. That computer needs to remain online with the ChatGPT app open for local work.

For a developer, that gives a practical path from a customer problem to a code task. The dot can keep track of the responsibility while Codex works on the repository. OpenAI's [tasks and memory guide](https://learn.chatgpt.com/docs/dots/tasks-and-memory) describes where those tasks run.

Its cloud browser supports inspection and takeover, with separate website sessions from your own browser. The [computer and apps guide](https://learn.chatgpt.com/docs/dots/computers-and-apps) explains sign-in and local access.

I would consider this when the work regularly crosses between business context and my development environment. My [dots guide](https://flaviocopes.com/openai-dots/) covers that setup in more detail.

### Compare the approval rules too

Grok Bot's [Auto Review](https://docs.x.ai/grok-bot/approvals-security-and-privacy) supports Ask first and Allow automatically rules. If both match, Ask first wins. Automatically allowing an action still leaves it subject to the review's other checks.

Dots has [custom rules](https://learn.chatgpt.com/docs/dots/controls) for actions that can proceed, require an explicit request, need approval, or need a human handoff. Its proactive research tools are read-only; follow-up actions go through the applicable permissions.

Duet's documented approval boundary is especially easy to explain for everyday business tasks. I wouldn't assume identical behavior across the three just because each has an approval button. I'd test the exact operation I wanted to delegate.

## The same customer problem in each product

Suppose a customer emails that CSV export is broken and requests a call tomorrow.

This is how I would organize the work, based on those documented capabilities:

| Stage | Duet | Grok Bot | A dot |
| --- | --- | --- | --- |
| Prepare for the call | Ask it to collect the email and calendar context | Give that job to a customer-support Bot | Add it to the dot's customer-follow-up responsibility |
| Investigate the bug | Ask for a reproduction and a proposed next step | Have the Bot investigate and coordinate a Cursor task if needed | Have the dot investigate and create a Codex task in a prepared environment |
| Review the result | Inspect the brief, files, and proposed actions | Inspect the Bot's result and coding task | Inspect the delegated task through Activity |
| Reply to the customer | Review the exact message before approving | Require approval for external email | Set a rule requiring approval for customer messages |

The table describes a proposed workflow. A real test would need the same email, repository, and stopping point in every product.

I would judge the result by whether it reproduced the failure, kept the customer's words accurate, and returned something I could review. Producing a convincing explanation of a bug it never reproduced would fail the test.

Duet's launch includes app-building examples, but that doesn't establish feature parity with Cursor or Codex. If a job needs a particular repository setup or local toolchain, check that path directly.

## Cost and access can decide the choice

The access rules below were checked on October 22, 2026. Rollouts and allowances can change.

| Product | Access and usage |
| --- | --- |
| Claude Duet | US Pro and Max subscribers invited from the waitlist; shares Claude usage limits |
| Grok Bot | Included with paid individual Cursor plans and Cursor Teams; individual SuperGrok plans can also be linked; weekly usage allowance |
| ChatGPT dots | Gradual rollout to eligible Pro, Business Premium, and Enterprise accounts; Work and Codex tasks use those products' limits |

See [Claude pricing](https://claude.com/pricing), the [Grok Bot FAQ](https://docs.x.ai/grok-bot/faq), and [dots access rules](https://learn.chatgpt.com/docs/dots#access) before choosing a subscription.

Claude Pro is $20 a month when billed monthly, before applicable tax. Max starts at $100. Duet is included during the preview, but its background checks consume your allowance. I'd measure what is left for my other Claude work after a normal week.

Dots conversations don't count toward ChatGPT usage limits, while delegated Work and Codex tasks do. Its included deeper-work allowance means that distinction shouldn't be read as unlimited execution.

Pro dots access excludes the EEA, UK, and Switzerland and requires users to be over 18. Business Premium is rolling out worldwide; Enterprise requires administrator enablement. Duet's US restriction is a separate, narrower preview rule.

A lower subscription price doesn't settle the comparison if the product can't access your account or finish your workflow. I'd try the eligible product I already pay for before buying another subscription.

## How I use Grok Bot, and what I want to try with Duet

I already use Grok Bot for recurring work around this site. One job checks whether a scheduled post appeared and whether the deployment finished. It brings the results together in a short report, so I can see what needs attention without opening each page myself.

I also use it to check provider pricing for my [hosting picker](https://flaviocopes.com/hosting-picker/) and [payment picker](https://flaviocopes.com/payment-picker/). The work involves reading public pricing pages and comparing them with the information I maintain. I described these workflows in more detail in [Grok Bot vs Cursor Projects](https://flaviocopes.com/grok-bot-vs-cursor-projects/).

Those are the kinds of jobs I want to try with Claude Duet. I already know what a useful result looks like, and I can compare it with the work Grok Bot does for me.

I'd start with the site check. Ask Duet to look at the published posts and deployment status, then tell me if something needs my attention. I'd keep it to reporting while I check that it reads the right sources and catches a failed deployment or a missing post.

The pricing checks would be another useful test. I'd ask it to show the source and explain each change before updating anything. Provider pages often have conditions attached to a price, so I want to see whether it understands those conditions.

I haven't run either workflow in Duet yet. I want to see how it handles the same work, including whether it can access the tools it needs and how much of my Claude allowance it uses. I'd keep Grok Bot's existing routines running while I try it.

## What I don't like, and what I'd test first

The missing browser view is my biggest concern. I want a way to inspect where an agent is stuck, especially when it works with a signed-in website. Grok Bot and dots already document that ability.

Background usage is another concern. A helpful morning brief could be worth the allowance it uses. Repeated checks that find nothing useful would be harder to justify, particularly if they reduce what I can do in Claude during the day.

I'd also keep anything time-critical on a conventional alert. A system checking every few hours leaves gaps. For a deadline I cannot miss, I'd use the calendar's own reminder and treat the agent's preparation as additional help.

For fixed rules, I'd consider a script. If a job means checking one field and emailing when it passes a threshold, a scheduled program is easier to inspect. I explain those options in the [cron guide](https://flaviocopes.com/cron/).

My first Duet test would be a week of site checks alongside the reports I already get from Grok Bot. I'd compare what each one caught, what it missed, and whether I needed to step in to finish the job.