Claude Code Projects: Coordinator, /btw, /fork, and Usage Limits
Claude Code Projects now coordinates parallel coding threads, side questions, forks, reminders, and announced read-only sharing. Set up a project, review the default Opus/high-effort settings, limit parallel work, inspect token use, and stop automatic restarts after a plan-limit reset. Compare Projects with local CLI sessions, agent view, and T3 Code.
Contents

Claude Code Projects is best for related coding tasks that need one coordinator and several parallel sessions. As of November 14, 2026, Projects is a gradual Pro, Max, and Ultra beta. Its default Opus/high-effort configuration can exhaust shared plan limits sooner. Start with one small thread, lower the model and effort where possible, and disable Auto-continue if you want to protect your next usage window.
Anthropic’s November 14 update makes the coordinator more proactive. It also brings /btw, /fork, reminders, read-only thread sharing, and better artifact navigation into Projects.
The main reason to use Projects remains the same: you describe related work in one conversation, and Claude manages the sessions that perform it. Every running thread is a full Claude Code session consuming your existing allowance.
What are Claude Code Projects, and who can use them?
A Claude Code Project is one ongoing conversation with a coordinator that creates and manages separate working sessions called threads.
You might give it three tasks:
- Fix an authentication regression.
- Add missing tests for a payment endpoint.
- Investigate a slow database query.
The coordinator assigns tasks to separate threads, tracks progress, and reports results in the project conversation. Each thread receives the project’s instructions and can work independently.
Most threads run as Claude Code cloud sessions. Each cloud thread uses its own repository clone, sandbox, and branch.
You can also run a thread on your computer through Remote Control when it needs local tools or files. Unlike a cloud thread, that session stops working when its host computer is unavailable.
Projects differ from the older Claude.ai Projects experience. The older experience groups conversations and reference files; the redesigned Claude Code version adds active coordination and working threads.
Availability and the waitlist
As of November 14, 2026, Anthropic documents this availability:
| Plan | Projects availability |
|---|---|
| Pro | Public beta, gradual rollout |
| Max | Public beta, gradual rollout |
| Ultra | Public beta, gradual rollout |
| Team | Not offered yet |
| Enterprise | Not offered yet |
Having an eligible subscription does not guarantee that Projects has reached your account.
To check:
- Open Claude Code on the web.
- Look for Projects in the sidebar.
- If it is missing, open More in the sidebar.
- Alternatively, check the Code tab in the Claude desktop app.
- If Projects is still missing, visit the Projects waitlist.
You can also try the Projects browser page.
The rollout initially favored accounts that had used cloud sessions and had no existing Projects in Claude.ai chat or Cowork.
Projects is not a feature you enable by updating the terminal CLI. Anthropic provides it through the web, desktop, and mobile applications, subject to account eligibility.
What changed in the November 14 Projects update?
On November 14, 2026, at 06:51 UTC+8, Anthropic’s @ClaudeDevs account announced several Projects changes.
The update mainly improves how you interact with the coordinator and individual threads.
| Feature | What it does | When to use it |
|---|---|---|
| Proactive coordinator | Answers questions in project chat and reports thread status | Checking multiple tasks without opening every thread |
/btw | Creates a separate thread for a side question | Investigating something unrelated without interrupting current work |
/fork | Starts a new thread from the current thread | Trying an alternative implementation |
| Thread reminders | Hides a thread until its reminder is due, then surfaces it in project chat | Returning to work after a dependency or review |
| Read-only sharing | Announces links for individual threads, with eligibility restrictions | Showing a thread’s work to another Claude user |
| Artifact navigation | Surfaces recently opened, updated, or pinned artifacts and thread artifact thumbnails | Finding output from earlier work |
A more proactive coordinator
The coordinator now answers questions in the project conversation and provides more active status updates.
For example, after starting several tasks, you can ask:
Which threads are still running, which pull requests need review, and which tasks are blocked?
The coordinator can report what its threads have told it. It does not see every internal step of every thread.
This distinction matters when investigating a failure. Open the individual thread to inspect its commands, tool calls, and results.
Anthropic describes the change in its November 14 coordinator announcement.
/btw versus /fork
Both commands now work inside Projects, but they solve different problems.
Use /btw when a new question appears while another task is underway.
Suppose a thread is changing authentication middleware. You suddenly need to investigate an unrelated billing error.
Use /btw for the billing question. Projects creates a separate thread, leaving the original work focused on authentication.
Use /fork when you want to explore a different approach to the current task.
For example, an existing thread might be replacing a database query with a join. Fork it to investigate a materialized-view approach without replacing the original thread’s work.
The distinction is:
/btwseparates a new side task from your current task./forkbranches the current thread’s work into another thread.
Both can create additional sessions that consume plan usage. Avoid forking repeatedly without a reason to compare the results.
Anthropic documents the new Projects behavior in its announcement of both commands. Their behavior inside Projects should not be confused with every version of the terminal CLI.
Reminders, sharing, and artifact navigation
You can set a reminder on an individual thread or ask Claude to remind you about it.
According to Anthropic’s reminder announcement, the thread moves out of the way until the reminder is due. Claude then brings it back into the project conversation.
This is useful when a task needs a later decision. It does not remove the need to review its output.
Anthropic also announced read-only sharing for individual threads:
- Open the thread.
- Open its menu.
- Select Share, if the option is available.
- Send the link to someone signed in to Claude.
A thread that has accessed your computer cannot be shared through this feature.
There is a documentation mismatch as of November 14. The official announcement introduces individual thread sharing, but the Projects limitations page still says project thread transcripts cannot be shared.
Treat the announcement as the new behavior being introduced, and check whether your thread actually offers Share. No Projects-specific CLI-version requirement has been verified for this UI change.
Read-only access does not make a transcript safe to disclose. Review repository details, logs, and other sensitive information before sharing.
The artifact-navigation announcement describes a top row in the threads panel for recently opened, updated, or pinned artifacts. Each thread also shows thumbnails of its own artifacts. You can disable these thumbnails in view settings.
Anthropic says the updated settings and local-folder interface are available on web and desktop, with the new design in the latest mobile app.
Set up your first Claude Code Project
Create one project for an ongoing goal, then verify a small thread before delegating several tasks.
1. Check repository access
For a cloud thread working on code, Anthropic currently requires:
- A repository hosted on
github.com, rather than GitHub Enterprise Server, GitLab, or Bitbucket. - Push access through your connected GitHub account.
- The Claude GitHub App installed with access to the repository.
A GitHub token configured through /web-setup is not sufficient by itself for Project cloud threads.
Follow the official GitHub setup instructions if the repository is missing. First connect your GitHub account, then install the Claude GitHub App for the required repository.
For private repositories in organizations using SAML SSO, you may also need to authorize the Claude app for that organization.
Cloud threads load each repository’s CLAUDE.md instructions, but not its skills, .mcp.json servers, or .claude/settings.json. This also excludes hooks, permission rules, and environment settings in that file.
Cloud threads do not inherit tools installed only on your computer. Use the project’s cloud environment and supported Claude account integrations for required capabilities. Consider Remote Control for tasks that need your local tools.
2. Create the project
Anthropic’s Create a project documentation specifies these controls:
- Open
claude.ai/codeor the Code tab in the desktop app. - Select Projects in the sidebar or under More, then New project.
- Enter a Name for the project.
- Optionally enter a goal under What do you want to work on?
- Under Context, use + to add the GitHub repositories, files, or folders the work needs.
- Select Create project.
Only the name is required. You can add the goal and context later.
If you see Get started instead of New project, Anthropic may ask you to upgrade or archive existing Claude.ai projects first.
On your first project, Claude may take an initial turn immediately after creation. That turn uses plan allowance and can start an exploratory thread or suggest setup changes.
Review proposed repositories and scheduled tasks before accepting those recommendations.
3. Configure instructions and usage settings
Open Project settings from the project’s sidebar or header menu.
Go to Project settings > Memory > Project instructions and add rules for new threads.
For example:
Work only in the selected repository. Use a separate branch for each implementation. Run the relevant tests before reporting completion. Ask before changing public API behavior. Do not open a pull request until I approve the implementation plan.
New threads receive these instructions. Changes to instructions, repositories, plugins, and environments in Project settings reach new threads, not threads already running.
Next, open Project settings > General and review the model and effort settings described below.
4. Run one small task and inspect the result
Use a task with a clear success condition:
Investigate why the orders endpoint returns an incorrect status for invalid input. Start one thread. Identify the failing case, add a regression test, and propose a minimal fix. Do not open a pull request until I approve the plan.
This is an example prompt, not a report of an executed test.
In Overview, check the thread’s status. The pane groups threads under states such as Working, Waiting on you, and Ready for review.
Open the thread and inspect the evidence:
- Which files did it read or change?
- Did it run the requested tests?
- Is its explanation consistent with the diff?
- Does it need permission, a missing dependency, or a decision?
Cloud threads normally work on separate branches. They can open pull requests when asked and may open them for concrete fixes.
If the thread reports Couldn’t start the session or Unable to access your repository, check the GitHub App installation and repository access. Use the recovery action in the error message, then start a new thread for the task.
Project coordination does not eliminate Git merge conflicts. Two threads editing the same code can still produce conflicting changes.
Once the first thread behaves as expected, start a second independent task.
How to reduce Claude Code Projects usage
The first cost-control step is changing the default model and effort settings.
Anthropic states that a new Project uses Opus for both coordinator and threads, with high effort for threads and low effort for the project conversation.
That is a resource-intensive default for routine fixes, test updates, and documentation work.
Change Thread model, effort, and Auto-continue
Open Project settings > General.
| Setting | New-project default | Lower-usage starting choice |
|---|---|---|
| Thread model | Opus | A smaller model available to your account for routine work |
| Thread effort | High | Medium or low for bounded tasks |
| Coordinator model | Opus | A smaller available model for routing and status updates |
| Coordinator effort | Low | Keep low unless coordination quality needs more reasoning |
| Auto-continue when usage limits reset | On | Off if work must not resume automatically in the next usage window |
The exact model choices available can depend on the account and current model availability.
Use Opus with high effort when a task requires difficult debugging, architecture decisions, or substantial reasoning. A smaller model with lower effort is a better starting experiment for isolated tests or straightforward edits.
The settings have different responsibilities:
- Thread model and Thread effort control working sessions.
- Coordinator model and Coordinator effort control the main project conversation.
You can request a different model for one new task. For an existing thread, use that thread’s model picker.
These settings belong to the Projects interface, not your local settings.json.
Ask for fewer threads, but do not treat the request as a hard cap
Anthropic recommends asking the coordinator to propose threads before starting them.
A useful instruction is:
Propose the threads before starting work. Run at most two threads at a time. Answer small questions in this conversation instead of opening another thread. Report completed tasks and blockers, then wait for approval before starting another batch.
This controls the intended workflow, but Anthropic explicitly describes a requested thread count as a preference rather than an enforced concurrency limit.
The enforced limit is 500 new threads per day across your Projects. It is not an allowance of 500 free sessions or a guaranteed parallel-processing capacity.
Check Overview to confirm how many threads actually started.
Where the usage goes
According to Anthropic’s Projects usage documentation, four mechanisms matter.
Running threads: Every thread is a full session. Several sessions can consume your allowance simultaneously.
The coordinator: Reading reports, deciding what to do, and responding in project chat also use tokens.
Pull-request watchers: A thread watching a pull request can wake up when CI fails or a review comment arrives. That activity consumes usage again.
Long conversations: Returning to an old thread may require Claude to reread substantial conversation history.
For Pro, Max, and Ultra usage within the included plan limits, Anthropic documents a one-hour cache lifetime.
When a thread has been idle for longer than an hour, a follow-up causes it to reread its conversation. For genuinely new work, a fresh thread can use less than reviving a large existing one.
Do not create a fresh thread automatically for every follow-up. An existing thread may still be valuable when its prior investigation is needed.
Anthropic does not provide a fixed usage multiplier for Projects. Consumption varies with the number of threads, model selection, effort, conversation length, and repeated work.
You can inspect the actual distribution in Project settings > Usage. It shows token use by thread, by model, and by the project conversation.
For a related look at token overhead outside Projects, see our Claude Code agent_summary usage analysis. Its measurements concern background-agent summaries, not a measured Projects surcharge.
Does an idle Project consume usage?
Anthropic says a project with no running threads, no watched pull requests, and no new messages does not consume plan usage while idle.
An archived project also consumes no usage.
You do not need to delete a completed project merely to avoid idle consumption.
However, a thread still watching a pull request can become active again. Ask it to stop watching the pull request when that monitoring is no longer useful.
What happens when Projects reaches a usage limit?
Projects uses the same included limits as other Claude Code activity on your subscription. It does not have a separate pool of free tokens.
As of November 14, 2026, the applicable limits differ by plan:
| Plan | Relevant limits |
|---|---|
| Pro | Five-hour session and weekly limits |
| Max | Five-hour session and weekly limits |
| Ultra | Weekly limits; verified Ultra accounts have no five-hour limit |
An unverified Ultra account can still have a temporary session limit.
Anthropic’s Ultra plan documentation explains the verification exception. Our Ultra versus Max usage-limit guide covers the distinction in more detail.
Auto-continue can use your next allowance window
When a thread or the coordinator reaches an applicable plan limit, it waits.
By default, the stopped work resumes when the limit resets. That work counts against the new usage window.
To prevent this:
- Open
Project settings > General. - Find Auto-continue when usage limits reset.
- Turn it off before the displayed reset time.
- After the reset, send a message to restart work manually.
This is a project-wide setting. It does not apply only to the thread you were viewing.
Turning off Auto-continue does not automatically disable other paid usage options.
Usage credits are separate from included limits
Anthropic allows Pro, Max, and Ultra subscribers to enable usage credits for consumption-based billing.
When enabled, eligible requests can continue beyond included limits using paid credits. A Project thread cannot enable this option independently.
Before running a large batch, check Settings > Usage in your Claude account.
If usage credits are enabled, set a monthly spending cap that matches your budget. Disable them if you do not want consumption-based charges after included limits are exhausted.
These usage credits are distinct from monthly API credits included with Max and Ultra plans.
If a thread reports Additional usage credits are required, its requested model or context size may require credits that your account has not enabled.
Choose an included model or context option when available. Otherwise, review Anthropic’s usage-credit requirements before deciding whether to enable paid usage.
Projects versus local Claude Code sessions and T3 Code
Choose Projects when the value comes from ongoing coordination across related tasks. Choose local sessions when control over the environment or individual task execution matters more.
| Approach | Best use | Who coordinates | Main limitation |
|---|---|---|---|
| Claude Code Projects | Related work spanning multiple sessions, repositories, or days | Claude coordinator | Anthropic-only model provider, beta access, shared plan limits |
| Multiple local Claude Code CLI sessions | A few independent tasks needing local tools | You | You start, monitor, and coordinate sessions yourself |
| Claude Code agent view | Monitoring several local sessions in one interface | You dispatch and steer sessions | Research preview; no Project coordinator |
| T3 Code | Managing local coding agents, including Claude Code and Codex | You or configured agent workflows | Requires agent setup and a host machine |
Choose local CLI sessions for explicit control
For two independent coding tasks, separate local sessions and Git worktrees may be enough.
A worktree provides each session with its own checkout, reducing accidental overlap in the working directory.
Local sessions can use your installed tools, hooks, settings, and supported provider configuration. They do not automatically become Project threads.
Claude Code’s claude agents interface provides a research-preview agent view for dispatching and monitoring multiple sessions.
Anthropic compares these options in Run agents in parallel.
Choose this route when every task needs a local database, custom hooks, or infrastructure unavailable to Project cloud threads.
Choose T3 Code for cross-agent control
T3 Code is an open-source control interface for coding agents running on your machine.
Its documented integrations include Claude Code, Codex, Cursor, OpenCode, and other supported agents.
According to its public README, T3 Code displays agent threads in one interface and supports remote connections. A thread can use a Git worktree for isolated changes.
It uses the agents and authentication you configure rather than reselling tokens.
That makes it useful when you need to move work between different coding agents or monitor local work from another device.
T3 Code does not turn third-party sessions into Claude Code Projects or give them the same Anthropic-hosted coordinator. Your underlying providers still determine authentication, access, and billing.
See our T3 Code setup guide for Claude Code, Codex, and API gateways for the integration path.
Can Projects use a custom API key or model provider?
No custom provider path is documented for Projects.
Anthropic’s Projects limitations explicitly state that cloud threads and Remote Control threads use Anthropic as the model provider.
Projects also cannot be used directly through the terminal CLI, VS Code extension, or JetBrains plugin.
If a custom API endpoint is a requirement, use a compatible local coding tool or third-party orchestration interface instead. Verify that tool’s provider support separately.
A pay-as-you-go API route is not a replacement for the Projects coordinator, its account entitlement, or its cloud-session management.
A practical starting configuration
For an eligible Pro user working on a service with several small outstanding bugs, begin with this setup:
- Create one Project for the service and connect only the required repository.
- Put branch, testing, and approval rules in Project instructions.
- Select a smaller available Thread model and reduce Thread effort for routine tasks.
- Keep Coordinator effort low and consider a smaller Coordinator model.
- Ask for proposed threads and approve one or two tasks at a time.
- Turn off Auto-continue if the next usage window must remain available.
- Inspect
Project settings > Usageafter the first batch.
Keep Opus/high effort for investigations that justify it. Use /btw and /fork when separating work produces a clear benefit, rather than treating each question as a new session.
For a long-running migration across multiple repositories, Projects can remove manual coordination. For a few local changes, manual sessions or agent view may accomplish the same work with less overhead.