Research brief
- What this research adds
- This dossier adds a three-way decision rule for continuing, forking, or opening a clean thread, plus a source-by-source separation of documented behavior, first-party measurements, and inference.
- Research question
- When does forking reduce Computer credit use, and when is a clean thread cheaper?
- Method
- Reviewed Perplexity's June 18 forking announcement, live consumer and enterprise credit documentation, and Computer Analytics API documentation on 2026-08-23. Reconciled those sources with Karo's 45,000-credit first-party teardown and a published branching workflow. No controlled fork-versus-continue A/B test exists in the reviewed record, and Perplexity does not publish a formula tying inherited context to credits.
- Confidence
- Medium
- Evidence
- primary documentation, first-party credit tracking, practitioner workflow, dated absence check
- Next verification
TL;DR: Forking preserves context. It can reduce future credit use when you fork before a thread collects unrelated work, or when separate branches prevent several jobs from sharing one growing history. If a task needs no earlier context, a clean thread is the cheaper choice. Perplexity says a fork keeps full access to the previous thread's context and generated assets, with no promised credit reset or discount.
Evidence Ledger
| Claim | Evidence | Source type | Verified | Confidence | Caveat |
|---|---|---|---|---|---|
| Perplexity announced Computer forking on June 18, 2026. A fork opens a fresh thread with full access to the previous thread's context and generated assets. | Perplexity forking announcement | Primary documentation | 2026-08-23 | High | “Fresh thread” describes the interface. The same paragraph confirms that prior context remains accessible. |
| Perplexity has published no separate price, reset, or discount for a fork. Computer credits vary with task complexity and the computing resources used. | Perplexity credit documentation and forking announcement | Primary documentation plus dated absence check | 2026-08-23 | Medium | Perplexity does not publish its internal context-selection, caching, or credit-allocation formula. |
| In Karo's first-party tracking, the same SEO-audit job cost about 40 credits at message 5 and 200 to 320 credits at message 50. | Save Credits in Perplexity Computer: Advanced Guide, Part 2 | First-party observation | 2026-08-23 | Medium | Approximate values from one builder's tracking, not a controlled product benchmark. Task routing, models, tools, and platform behavior may have differed. |
| Karo's fresh-thread comparison measured up to 80% fewer credits for the same self-contained task, while her strategy-and-execution split cut creative workflow costs by roughly 40 to 50%. | First-party thread-management teardown | First-party observation | 2026-08-23 | Medium | Workflow-specific estimates. The article did not publish raw task logs or a fork-specific A/B run. |
| The consumer usage page breaks credits down by thread, and each thread's Usage dropdown shows the credits spent on a single task. | Perplexity account usage documentation | Primary documentation | 2026-08-23 | High | The dashboard shows outcomes. It does not explain why the orchestrator chose a particular model, tool count, or context slice. |
| Perplexity's Enterprise Analytics API reports credit time series by hour or day, with breakdowns by member, model, and credit source. Its published schema exposes no thread identifier. | Computer Analytics API documentation | Primary documentation plus dated schema check | 2026-08-23 | High | The web dashboard may expose views that the API does not. The schema can change after verification. |
| Consumer Max includes 10,000 credits per month. The default monthly spending cap is $200 and can be raised to $5,000. | Perplexity credit and spending-limit documentation | Primary documentation | 2026-08-23 | High | Prices, allowances, promotions, and regional terms can change. |
| A published branching workflow starts with one source-rich brief, then forks competitor, customer, risk, and action branches so each output grows from the same evidence without mixing jobs. | Perplexity Computer Branching Research Workflow | Practitioner workflow | 2026-08-23 | Medium | The workflow demonstrates branch design. It publishes no credit comparison. |
Where the Evidence Conflicts
Perplexity calls a fork a “fresh thread” and says it keeps full access to the previous thread's context and assets. Both can be true. Neither proves that inherited context disappears from the bill. No official page says a fork resets context, applies a discount, or costs less than one more message in the original thread.
The guide cannot calculate savings. Its summary gives light tasks 15 to 70 credits. The same page's table lists 100 to 350. Those ranges disagree, and Perplexity leaves model routing, tool calls, context selection, and caching out of its public formula.
My earlier tracking supports the cost of long threads, including one SEO-audit comparison that rose from about 40 credits near the start of a thread to 200 to 320 near message 50. It did not test forking. A message-50 fork may still expose the bloated history. A message-12 fork can leave later clutter behind.
The defensible claim stays narrow. Forking can prevent future context growth and separate branches. It has no documented reset button.
What I Tested
I burned through 45,000 Computer credits while stress-testing coding, visual, research, and content workflows, then compared recurring patterns in the task history. The advanced credit-saving guide records two findings used here: self-contained work was much cheaper in clean threads, and splitting strategy from production cut estimated creative-workflow costs from 350 to 500 credits down to about 200.
Forking did not exist yet. I have not published a controlled A/B run comparing the same task in three states: continued thread, forked thread, and clean thread. This dossier joins old measurements with the documented feature behavior. That remains an inference.
I checked every official cost surface. Personal accounts can inspect usage by thread and task. Enterprise charts split credits by time, member, and model. Neither reveals the inherited token count.
Change Log
| Date | Change found | Evidence affected | Conclusion changed? |
|---|---|---|---|
| 2026-08-23 | Initial verification after the June 18 forking release | All claims | Initial draft |
My Judgment
My Conclusion
Forking is useful context surgery. It is poor context laundering.
Use a fork when the next job needs the evidence, assets, or decisions from an earlier thread and should branch before later clutter. Use a clean thread when the brief is enough. Continue inline for the same job.
What Builders Should Do
Use this three-way rule before the next prompt:
| What the next job needs | Choose | Credit logic |
|---|---|---|
| No earlier context | Clean thread | Carries no conversation history. |
| A finished plan saved as a file | Clean execution thread | Loads the handoff artifact without the planning conversation. |
| One useful point from an earlier thread | Fork at the last clean point | Preserves the relevant branch and leaves later clutter behind. |
| The same decision, same artifact, and same evidence | Continue | The existing context still serves the job. |
| Several outputs from one evidence base | One fork per output | Stops competitor research, risk analysis, copy, and task planning from accumulating in one history. |
Save the handoff. Include the decision, facts, constraints, questions, and next deliverable. My first Computer credit guide also recommends a precise prompt and a bounded output. “Make this better” lets Computer guess the scope.
Then measure. Record the thread URL, task type, branch point, credits used, model, tool count if visible, and whether the result needed repair. Your account data beats another universal percentage.
What I Would Not Trust Yet
I would not publish a universal fork-saving percentage. The 80% fresh-thread figure and 40 to 50% two-thread figure came from my workflows, while Perplexity's billing system can route tasks across different models and tools. The fork rate is unpublished.
I would also avoid treating “full access” as proof that every prior token is reprocessed. Perplexity may retrieve, summarize, cache, or select context. Perplexity has not documented which mechanism Computer applies to forked threads.
What Would Change My Mind
A controlled three-way test would raise my confidence. Published context-token usage would settle the mechanism. If a fork created at the end of a long thread repeatedly matched a clean thread's cost, the current decision rule would need revision.
FAQ
Does Forking a Perplexity Computer Thread Reset Credit Use?
Perplexity promises no reset. The June 18 announcement says a fork opens a fresh thread while retaining full access to the prior thread's context and generated assets. That supports continuity, not zero carried context. A branch after fifty mixed-purpose messages may still carry a large source history, so open a clean thread when the next task needs none of it.
Is a Fork Cheaper Than Continuing the Same Computer Thread?
Sometimes. A fork can cost less over the next several tasks when it leaves unrelated later work behind or prevents several outputs from sharing one growing conversation. Perplexity publishes no fork discount, and no controlled public test proves that the first message after an end-of-thread fork costs less than the same message sent inline. Credit savings come from cleaner branch points.
When Should I Fork Instead of Opening a Clean Thread?
Fork when the next task depends on prior evidence, files, design decisions, or generated assets that would be tedious or risky to reconstruct. Open a clean thread when the handoff is enough. A clean thread avoids inherited conversation history. The practical test is simple: if you can describe the job completely in a brief and attach the required files, you probably do not need a fork.
How Can I Measure Whether Forking Saves Credits for My Work?
Run the same bounded task three times: once as a follow-up in a long thread, once from a fork at the last relevant message, and once in a clean thread with a saved handoff file. Keep the prompt, files, output, and model fixed. After each run, record credits from the Usage dropdown. Repeat on several tasks because Computer can change routing and tool use, then compare medians rather than one dramatic result.
Share this with a friend whose Computer thread should have ended yesterday.
Subscribe to Product with Attitude for more free credit-saving workflow rules for builders who want more shipped work per 10,000 credits.