A Claude duet workflow is two parties, you and a second person or a second Claude session, working from the same saved instructions and passing work back and forth, much as a team might hand a task along a chain of automated steps built in Activepieces.
A Claude duet workflow is a working arrangement in which two parties, either two people or a person and a second Claude session, share one set of saved instructions, such as a project or instruction file, and take turns building on each other's output.
As of 17 November 2026, no Anthropic page uses the word "duet", so this is a pattern built from documented parts, not a named feature.
Claude Duet Workflow Defined and the Fastest Path
What "duet" means in Claude documentation
You will not find the pairing in the docs. Anthropic documents the integrations: plans, models and saved instructions. Nothing in the docs promises a duet mode, so nothing here depends on one.

If you later connect the two parties through Activepieces, the same pattern holds, and its 750 integrations cover wherever the output needs to land.
For the model, Claude Sonnet 5.5 is listed as the best combination of speed and intelligence, which makes it the sensible default for a back-and-forth.
Because each stage below runs on its own before you start the next, a failure at stage three never costs you stage one. Total setup is about 20 minutes.
- A two-party Claude session, with both parties signed in.
- Saved instructions both parties share.
- One complete round trip: a request out, a reply back.
- One documented limit, identified before it interrupts you.
Start with the plan, because the first item depends on it.
Claude plan and account requirements for a duet
You need a paid Claude seat for each party, and the price on the pricing page depends on how you pay. According to Anthropic, Pro's $20 per month, or $17 on annual billing, so annual saves $3 per seat each month.
At $25 monthly or $20 annual, per Anthropic, Team Standard makes two seats cost $40 a month instead of $50, saving $10 monthly.
Per Anthropic, Team Premium's $125 monthly or $100 annual, a $25 monthly difference per seat, and the one where billing choice matters most.
If you want to trial the workflow, put it on monthly pricing, because annual billing's a commitment. The chart below sets all three side by side.
Everything below works on Activepieces' free plan. Start without code or a credit card.
Five stages of Claude duet workflow setup
By the end of five stages you have a working two-party Claude setup, and each one ends with something you can see running before you start the next.
Skip the check at the end of a stage and the failure shows up two stages later, where it's harder to trace.
Stage 1: Sign in and confirm your plan
Stage 1 is signing in and confirming your plan includes the feature. Sign in at claude.ai, open your profile menu and choose Settings, then look at the sidebar. If Projects is listed there, your plan includes it.

If the entry is missing or the create button is greyed out, stop. Nothing in the later stages will work, and the plan page in Anthropic's help center is the place to resolve it.
Stage 2: Create the Drafter
Create the first session or project with a role prompt; that is stage 2. Open Projects and select the button to create a project. Name it for the role, such as "Drafter".
Open the project's instructions field and write one sentence stating what this party does and one stating what it never does. The result's a project whose first chat already behaves as that role, without you restating it.

Stage 3: Create the Reviewer
Once the Drafter exists, stage 3 is creating the second session with the same context. Create a second project the same way and name it "Reviewer".
Give it the same background material as the first, uploaded to project knowledge, but opposite instructions: it critiques and doesn't write.
If anything is missing from this second copy, it is invisible to the Reviewer, because Claude doesn't share memory between separate projects. Ask it to summarize the background and compare the summary with the first project's.

Running the round trip and saving the setup
Now pass work between the two and run one round trip; that is stage 4.
- Give the Drafter a small task and copy its full reply.
- Paste that reply into a new chat in the Reviewer, with a line saying it's a draft to critique.
- Copy the critique back into the Drafter and ask for a revision.
If the revision visibly answers the critique, that's your proof. If it ignores the critique, the paste lost something, so fix that before adding any automation.
Stage 5 is saving the setup so it repeats. Copy both instruction texts into a plain document kept outside Claude, along with the list of knowledge files each project holds.
Projects can be edited by accident, and a document is the only record of what they said when they worked. Rebuilding from it should take minutes, not an afternoon.
Limits and Errors in a Claude Duet Workflow
Claude duet limits you will hit
To make that rebuild quick, you need to know which walls the two sessions will hit, and each one has a documented name and a fix.
The table below lists four, with the symptom you'll see and the Anthropic page to check before you trust any number you read elsewhere.
I've left out anything not stated on an official page, which is why some rows have no figure.
| Limit | Documented value | Symptom seen | Fix | Anthropic page |
|---|---|---|---|---|
| Usage per plan | Free plan: limited usage every 5 hours and every week | Session stops mid-task with a usage notice | Split work across resets, or move up a plan | Claude pricing |
| Context window | Set per model on its model page | Earlier instructions get ignored | Restart from a summary file | Anthropic model overview |
| Rate-limit error | Set per account tier in the API docs | Request rejected, then succeeds on retry | Back off and retry | Anthropic API rate limits page |
| File upload | Stated in the help center | Upload refused | Split or trim the file | Anthropic help center |
Prices and plan limits checked against docs.claude.com and claude.com and openai.com and gemini.google on November 16, 2026.
With the limit and the page to confirm it in hand, what follows is how each one shows up in a two-party setup.
On the free plan, usage is limited every five hours and every week, so two sessions working in parallel can leave you locked out mid-handoff.
If both parties run on one account, treat the allowance as shared and plan the stages to finish inside a window.
When a long thread goes wrong, nothing announces it. It starts dropping the instructions you gave first. Keep a short brief file that both sessions reread, and restart from it rather than extending a tired conversation.

When a request is rejected, that isn't a broken workflow. Log the timestamp and the error text, wait, and retry with a growing delay. If the error repeats, check your tier on the API rate limits page, not a forum post.
When their answers diverge, the cause is usually that one lost the brief, not that one's wrong, because neither session sees the other's thread. Paste the same brief into both, ask each to state the current task in one line, and compare those lines first.
Easier to see it running than to read about it: set it up free, no card.
Connecting a Claude Duet to Other Apps With Activepieces
Activepieces is no part of setting up Claude itself; it only comes in when the duet's output, a drafted reply for Slack or a sheet row, has to leave on a trigger.
Once an integration is connected there, an agent can call it: the same piece runs as a step in the flow that delivers the duet's output and as a tool on the project's MCP server, which Claude, ChatGPT, Cursor or an agent you wrote can reach.

Nothing gets published or exported twice. The Integrations Framework and MCP Server documentation describe this, and packages/integrations in the open source repo, where the 750 integrations are counted and where MoneyGram, Moneypenny, Alan and FundingSocieties' own platform is built, holds the one action behind both.
When automation is worth adding to a duet
Start with the generic route: the Anthropic API accepts a prompt from any tool that can send a web request, so nothing here requires Activepieces.
Activepieces is one convenient wrapper around that call, with its own Claude integration, one of 750 in an MIT-licensed core, so you skip writing the request yourself.
The duet is still two Claude conversations. Automation only moves their results.
Read the situations below as a test of where a person is currently the courier between tools; they separate the cases.
- Copy-paste is enough when you run the duet: a few times a week and read every answer before acting on it, because the reading is the work.
- Copy-paste is enough when the output stays in the conversation, such as a draft you'll rewrite by hand.
- Activepieces earns its place when the same brief arrives repeatedly from the same source, such as a form or a sheet row, and a person is retyping it each time; flows are unlimited on every plan, including free, so one per source costs nothing extra.
- Activepieces earns its place when the result must appear in Slack or a Google Sheet on schedule, whether or not anyone is at their desk.
If none of the last two describe you, stop here. An automation you don't need is one more thing that fails silently.
Build the handoff in this order, and run each step before adding the next. A flow that has never run end to end can't tell you which part broke.
An automation you don't need is one more thing that fails silently.
- Add the trigger: a new sheet row, an incoming webhook, or a schedule. Run it once and confirm the sample data shows the brief you expect.
- Add the Claude action from the Activepieces Claude integration and map the trigger's brief into the prompt. Check the returned text against what your manual duet produced for the same brief.
- Add the delivery step, a Slack message or a sheet update, and map Claude's output into it. Send one test and read the result where your team will actually read it.
Start your first Claude duet workflow this week
Pick one real task, run all five stages on it this week, and note which documented limit stops you first. That limit tells you what to fix next, and it's the part a plan on paper can't tell you.
- Choose one task you already do by hand, with a real input and a real person waiting on the output.
- Run the five stages in order, and don't start a stage until the one before it's produced output.
- Write down which limit hit first, with the exact error text and the timestamp.
- Re-check Anthropic's docs and pricing page against what you assumed.
- Put a re-verify date on the calendar today, then measure after a week.
Use something with a messy attachment or an awkward handoff between the two parties, because a demo input hides the failures a real one exposes.
If a stage fails, stop there and fix it. Don't stub it and move on, because a stubbed stage is a limit you've only postponed.
Logging the first Claude duet limit you hit
Keep this to a screenshot of the error state, the time it appeared, and which stage was running. Don't paraphrase it from memory.
When plan and rate limits surface, it tends to be as a vague failure partway through a run, and a log entry with a timestamp lets you match it against the documentation later instead of guessing.
The first limit is the one to plan around. Later ones may never matter for your volume.
Re-checking Claude documentation on a schedule
For plan names, limits and supported features, the source is Anthropic's pricing page and its documentation. Read them again before you commit, not after something breaks. Set a re-verify date now, and put it in a calendar entry rather than in your head.
Compare three things from your log after a week. They are how often the flow completed without you touching it, which limit hit first, and how much of your time it saved against doing the task by hand.

If the docs have changed since Monday, update the plan before you add anything new.
Frequently asked questions
Is Claude duet an official Anthropic feature?
Not under that name, as far as the docs you checked above show.
Treat a duet as a pattern you assemble from documented parts, two sessions or two agents with defined roles, and confirm on Anthropic's Claude Code and Agent SDK documentation pages that each part still exists before you build on it.

Do I need a paid plan to run a duet workflow?
It depends on which surface you use, and the plan page is the only place to settle it.
Because subscription plans for the Claude apps and API usage are billed separately, a plan that covers one session in the app doesn't cover a second party calling the API.
Read Anthropic's current pricing page and the usage-limit notes in the help center before you assume either.
Can two Claude sessions share memory or files?
Not conversation memory. Each session starts with its own context, and nothing one says reaches the other unless you carry it across.
Outside the conversation, the two sessions can share files in the same working directory and a project memory file such as CLAUDE.md, which the Claude Code documentation describes as loaded at session start. Hand-offs should go through those files, not through hope.
Why does the second session ignore my instructions?
Because it never received them. Instructions typed into the first session's chat exist only in that session, so the second one is working from a blank brief.
Move the rules into a shared memory file or into the second session's own system prompt, then ask it to restate its role before it does any work. If it restates them wrongly, the problem is the file, not the model.
Can I run a Claude duet through the API instead of the app?
Yes, and for a two-party setup it is often the easier route to control. When you use the API, each party is a separate call or agent with its own system prompt, and you decide exactly what passes between them.
The Messages API reference and the Agent SDK documentation describe the calls and options; read the rate-limit page there before you let the two parties loop on each other.


