Solanasis Docs

claude-code-browser-last-research-stack_handoff_2026-03-15

27 min read

Claude Code Research Stack, Browser-Last Configuration, and Subscription Strategy

Research-grade guide / playbook / briefing memo / AI handoff
Prepared: 2026-03-15
Prepared for: Dmitri / Solanasis
Prepared by: ChatGPT
Review mode: Serious self-review pass completed (no separate reviewer agent was available)

Executive Summary

This memo extracts, verifies, and improves the key conclusions from the discussion about:

  • why cloud co-work / Claude Code can end up using browser sessions heavily for research,
  • how to make browser use the fallback rather than the default,
  • whether skills are the main answer,
  • how MCP servers, hooks, permissions, and plugins actually fit together,
  • whether Perplexity Pro is worth it,
  • whether the Fireflies.ai / Perplexity promotion changes API economics,
  • and what the best “pro-grade research” stack is when Claude Code alone feels weak for deep research.

Core conclusions

  1. [Verified] Claude Code is extensible enough that browser-first research is not the only path and usually should not be the default. It supports CLAUDE.md, skills, hooks, MCP servers, permissions, plugins, browser integration, and remote/cloud modes. Official docs support a browser-last architecture. [R1][R2][R3][R4][R5][R6][R7][R8]

  2. [Verified + reasoned inference] Skills help a lot, but they are not the strongest control layer.
    The strongest practical control order is: permissions → hooks → MCP/tool selection → CLAUDE.md / skills → plugins.
    This is derived directly from the official mechanics: CLAUDE.md is context, permissions can deny, and PreToolUse hooks can block tool calls. [R3][R4][R6][R7]

  3. [Verified] Browser-heavy behavior can happen even if the repo itself does not explicitly say to do it. Common causes include:

    • Chrome/browser tools enabled by default,
    • Chrome automatically available in VS Code if the extension is installed,
    • user-level or local settings outside the repo,
    • Claude.ai MCP servers automatically flowing into Claude Code,
    • and plain tool availability influencing tool choice. [R2][R5][R8][R21]

  4. [Verified] Official Perplexity MCP integration requires an API key. Perplexity Pro is not the same thing as API access. API usage is separate and pay-as-you-go. Perplexity’s own help center says no Perplexity subscription is required for API usage, and their plan comparison says the API has no complimentary API credits. [R10][R11][R32][R33]

  5. [Verified] The Fireflies.ai / Perplexity promotion is real in official Fireflies materials: Fireflies Pro and Business customers can get one year of Perplexity Pro free. [R35][R36]

  6. [Verified + important nuance] That Fireflies promotion does not solve the Claude Code / API backend problem by itself.
    It gives you Perplexity Pro product access, which is useful for human-led research in the Perplexity app/web experience. It does not convert Perplexity into an included API backend for Claude Code MCP usage. API remains separately billed. [R32][R33][R34]

  7. [Verified] If you want browser/mobile access while keeping your local tools, local MCP servers, and local project configuration, Anthropic’s intended solution is Remote Control, not ordinary cloud web sessions. [R13][R14][R15]

  8. [Verified in part; community-supported in part] The best practical setup is usually a small research stack, not a giant tool pile:

    • one search MCP,
    • one extract/crawl MCP,
    • browser gated behind Ask or Deny,
    • one research skill,
    • optional hook if the model still misbehaves.
      The official docs support the tool-overhead side; community reports reinforce the operational pain of too many tools. [R8][R21][C1][C2][C3]

  9. [Partially verified / tentative] Codex can be part of the solution. Official OpenAI docs confirm that Codex has built-in web search, reads AGENTS.md, supports skills, and can run as an MCP server. What is not fully verified here is a turnkey “Claude Code automatically uses my local Codex as a research backend” setup. That remains a plausible but more advanced integration path. [R16][R17][R18][R19][R20]

Best current recommendation

For pro-grade research through Claude Code, the strongest practical setup is:

  • Human-led research seat: Perplexity Pro (especially if free via Fireflies) or Perplexity Max if you truly live inside Perplexity’s own product
  • Claude Code backend: Exa MCP or Tavily/Brave for search, plus Firecrawl or Tavily extract/crawl
  • Control layer: browser set to Ask or Deny; research skill added; hook only if still needed
  • Secondary verifier: use Codex as a parallel checker / second-opinion researcher if you already have it

That is better than buying Perplexity Pro and expecting Claude Code to suddenly become a top-tier research agent.

Purpose of This Document

This document is meant to function as all of the following:

  1. Guide / playbook for configuring Claude Code or similar cloud co-work tooling into a browser-last research stack.
  2. Briefing memo separating verified mechanics from guesses, vendor marketing, and community anecdotes.
  3. Decision memo for whether Perplexity Pro, Fireflies, Exa, Tavily, Firecrawl, Brave, and Codex are worth using.
  4. Handoff document for another AI so work can continue without the original transcript.

Discussion Context

User goals

  • [User-stated] Cloud co-work keeps using browsers for research.
  • [User-stated] The user wants browser use limited to cases where it is truly necessary.
  • [User-stated] The user suspects that plugins, skills, or MCP servers should allow better research workflows than repeated browser sessions.
  • [User-stated] The user wants verified, current guidance from official docs plus user-reported sites.
  • [User-stated] The user wants to know whether:
    • a free Perplexity account can be used directly,
    • Perplexity Pro is worth it,
    • the Fireflies.ai promo changes the economics,
    • other subscription-based research models should be considered,
    • and whether Codex can help.

User constraints / preference signals

  • [User-stated / prior preference] Wants highly structured, operationally useful Markdown handoff artifacts.
  • [User-stated / prior preference] Strongly prefers verification and explicit uncertainty.
  • [User-stated / contextual] Already has access to Codex and is evaluating Claude Code as part of a broader AI operating stack.

Evidence Status Key

  • Verified — directly supported by reviewed official documentation or similarly strong sources.
  • User-stated — came from the user and was not independently verified here.
  • Assistant-stated but unverified — appeared in prior discussion but could not be confirmed.
  • Tentative / speculative — plausible implementation path, inference, or design recommendation not fully verified end-to-end.

Key Facts and Verified Findings

1) How Claude Code is actually structured

  • [Verified] Claude Code combines built-in tools for file operations, search, execution, and web access, plus an extension layer that includes CLAUDE.md, skills, subagents, hooks, MCP, and plugins. [R1][R7]
  • [Verified] Anthropic explicitly says Claude treats CLAUDE.md and auto memory as context, not enforced configuration. [R3]
  • [Verified] Permissions are managed via /permissions and support allow, ask, and deny rules. [R4]
  • [Verified] PreToolUse hooks can return allow, deny, or ask; deny cancels the tool call and feeds the reason back to Claude. [R6]
  • [Verified] Skills support frontmatter like disable-model-invocation, allowed-tools, context, agent, and hooks. [R5]
  • [Verified] Plugins can package skills, agents, hooks, MCP servers, and LSP configurations. [R7][R9]

2) Why browser-heavy behavior can happen even if the repo does not say so

  • [Verified] Chrome can be enabled by default via /chrome, and Anthropic warns this increases context use because browser tools are always loaded. [R2]
  • [Verified] In VS Code, Chrome is available whenever the Chrome extension is installed. [R2]
  • [Verified] Claude Code settings exist at managed, user, project, and local scopes; user settings live under ~/.claude/, project settings under .claude/, and local settings under .claude/settings.local.json. [R4]
  • [Verified] Claude.ai MCP servers are automatically available in Claude Code for logged-in users unless ENABLE_CLAUDEAI_MCP_SERVERS=false is set. [R8][R21]
  • [Verified] MCP tool-search behavior is enabled by default and exists specifically because large MCP tool definitions can consume context. [R8][R21]
  • [Reasoned inference; strongly supported] So even if the project repo itself does not contain explicit browser-first instructions, browser-heavy behavior can still originate from:
    • enabled browser tools,
    • inherited user/local settings,
    • synced MCP/connectors,
    • or Claude simply selecting the most available permissive tool. [R1][R2][R4][R8]

3) Skills are useful, but not the whole answer

  • [Verified] Skills are reusable workflows that Claude can auto-load when relevant, or you can invoke them manually. [R5][R9]
  • [Verified] Anthropic shows an explicit example of a research skill using context: fork and agent: Explore. [R5]
  • [Verified] Skills can grant tool access while active via allowed-tools. [R5]
  • [Verified] Skills can be made manual-only with disable-model-invocation: true. [R5]
  • [Verified + conclusion] Skills are therefore best for:
    • workflow guidance,
    • discoverability,
    • provider-specific playbooks,
    • and structured output rules.
      They are not the most reliable enforcement layer. [R3][R4][R5][R6]

4) Hooks and permissions are the hard controls

  • [Verified] Permissions can deny or require approval for tools. [R4]
  • [Verified] Hooks can inspect tool events and return deny decisions before a tool runs. [R6]
  • [Verified] MCP tools can be matched in hooks using the mcp__<server>__<tool> naming pattern. [R6]
  • [Verified + conclusion] Therefore, if the goal is “browser only when absolutely necessary,” the correct native control path is:
    1. restrict browser tools with permissions,
    2. optionally add hooks for deterministic enforcement,
    3. then use skills to teach better behavior. [R4][R5][R6]

5) Remote Control vs cloud web sessions

  • [Verified] Remote Control keeps the session running on the user’s own machine, and the browser/mobile UI becomes a window into that local session. Local filesystem, local MCP servers, tools, and project configuration remain available. [R13]
  • [Verified] Claude Code on the web runs on Anthropic-managed cloud infrastructure. [R13][R15]
  • [Verified] Plugins are not available for remote sessions. [R14]
  • [Verified] In cloud sessions, repository-level hooks can run, but user-level settings do not carry over. [R15]
  • [Verified + implication] If the user wants browser/mobile access without losing local research tooling, Remote Control is the right mode. [R13][R15]

6) Perplexity: product vs API

  • [Verified] The Perplexity MCP server setup requires PERPLEXITY_API_KEY. [R10]
  • [Verified] Perplexity’s API billing docs say API credits are purchased separately on a pay-as-you-go basis, and Perplexity Pro is not required for API usage. [R33]
  • [Verified] Perplexity’s plan comparison says the API/Sonar path has no complimentary API credits and uses pay-as-you-go pricing. [R32]
  • [Verified] Perplexity’s help center says Pro, Education Pro, and Max are product plans; API is a separate developer/business product. [R32][R33]
  • [Verified] Perplexity’s current individual web pricing page shows the personal plan at $17/month when billed annually. [R34]
  • [Verified] Perplexity Pro includes advanced AI models and monthly limits for Research queries and Browser Agent/Comet usage, but this applies inside the Perplexity product, not programmatic API access. [R32][R34]
  • [Verified] Perplexity’s credit system described in “How Credits Work” refers to Perplexity’s newer premium product features (such as Computer on Perplexity), and the help center says personal Pro credit access is “coming soon,” with Max users receiving credits today. That is separate from API billing. [R34a]
  • [Conclusion] Perplexity Pro can be excellent as a human research seat, but it does not replace API billing for Claude Code / MCP integration. [R10][R32][R33][R34a]

7) Fireflies.ai promotion: what it does and does not do

  • [Verified] Fireflies officially announced that Pro and Business customers can get one year of Perplexity Pro for free; Enterprise customers get three months of Perplexity Enterprise Pro. [R35][R36]
  • [Verified] Fireflies’ current pricing page shows:
    • Pro: $10/seat/month billed annually
    • Business: $19/seat/month billed annually [R37]
  • [Verified] Perplexity’s help center says promotional/trial subscriptions require a valid payment method and auto-renew unless cancelled before the promotional period ends. [R36]
  • [Reasoned calculation] If the promotion is active and redeemable, Fireflies Pro annual pricing (17/month billed annually ($204/year), but only if you actually want Fireflies too. [R34][R35][R37]
  • [Critical nuance] Buying Fireflies just to get Perplexity Pro still does not solve Claude Code API/MCP backend costs. [R32][R33][R35]

8) MCP provider options for Claude Code research

Exa

  • [Verified] Exa offers an MCP server for Claude Code and other agents. [R25]
  • [Verified] Exa MCP is documented as free to use and says no API key is required for the remote MCP endpoint. [R25]
  • [Verified] Exa also says the MCP has a generous free plan and that adding your own API key lifts rate-limit ceilings. [R25]
  • [Verified] Exa supports web search, code context search, company research, people research, crawling, and deep-research tools, depending on configuration. [R25]
  • [Verified] Exa provides official Claude-oriented skills (company research, people research, papers, code search, etc.). [R26]
  • [Verified] Exa pricing for its API is request-based; the pricing page shows 1,000 free requests/month, search at 1/1k pages per content type, answer at $5/1k answers, and agentic search/research pricing for deeper workflows. [R38]
  • [Interpretation] Exa is one of the best low-friction options because you can test the MCP without paying first, then scale with an API key if it proves useful.

Tavily

  • [Verified] Tavily offers an MCP server with real-time web access. [R29]
  • [Verified] Tavily offers official agent skills for search, extract, crawl, and research. [R30]
  • [Verified] Tavily pricing is simple and credit-based:
    • Free: 1,000 credits/month
    • Pay-as-you-go: $0.008/credit
    • Monthly plans from 500 depending on credits
    • Enterprise custom pricing [R39]
  • [Verified] Tavily’s own best-practices guidance recommends a two-step workflow: search first, then extract. [R31]
  • [Interpretation] Tavily is attractive if you want predictable monthly pricing and one provider that covers search plus extraction.

Firecrawl

  • [Verified] Firecrawl documents a Claude Code MCP setup and says Claude can automatically use its search and scrape tools once configured. [R27]
  • [Verified] Firecrawl says the skill is the fastest way for agents to discover and use Firecrawl, and warns that without the skill the agent may not know Firecrawl is available. [R28]
  • [Verified] Firecrawl billing is subscription-based, not pure pay-as-you-go. [R40]
  • [Verified] Firecrawl paid plans are monthly-credit plans; the docs list Free, Hobby, Standard, Growth, Scale/Enterprise, with auto-recharge for overflow and no rollover of unused monthly allotments. [R40]
  • [Interpretation] Firecrawl is strongest as the crawl/extract layer rather than the only research system. It is especially useful when search alone is not enough.
  • [Verified] Brave Search API is based on Brave’s independent web index and is positioned for AI and agentic search use cases. [R23]
  • [Verified] Brave says its API surfaces recent events and includes $5 in free monthly credits. [R23][R41]
  • [Verified] Brave pricing currently shows:
    • Search: $5 / 1,000 requests
    • Answers: 5 / 1M input/output tokens
    • $5 free monthly credits [R41]
  • [Verified] Brave maintains an official skills repository for AI coding agents. [R24]
  • [Interpretation] Brave is attractive if you want a classic search index with simple request economics and official skills support.

9) Codex

  • [Verified] Codex enables web search by default for local tasks and uses cached search by default unless switched to live or disabled. [R16]
  • [Verified] Codex reads AGENTS.md files before starting work. [R18]
  • [Verified] Codex supports skills. [R20]
  • [Verified] Codex can run as an MCP server with codex mcp-server. [R17]
  • [Tentative / plausible] If the user already has Codex access, using it as a second-opinion researcher may reduce the need to buy a new research seat immediately. What remains unverified here is a clean, low-friction Claude Code → Codex research bridge that is worth the complexity for this user right now. [R17][R18][R20]

Major Decisions and Conclusions

A. The easiest durable fix is not “more browser”

  • [Verified + conclusion] The best browser-last approach is:
    1. restrict browser tools,
    2. add non-browser research tools,
    3. encode the workflow as a skill,
    4. add hooks only if behavior still drifts. [R2][R4][R5][R6]

B. Skills are worth using, but not as the only fix

  • [Verified + conclusion] A research skill is worth adding because it gives Claude a structured default and improves discoverability. But permissions and hooks do the real forcing. [R3][R4][R5][R6]

C. Perplexity Pro is worth it only in the right role

  • [Verified + conclusion] Perplexity Pro is worth claiming—especially if free via Fireflies—as a human-operated research cockpit.
  • [Verified + conclusion] It is not the right purchase if the expectation is “this will make Claude Code’s MCP-based research free.” API remains separate. [R32][R33][R35]

D. The best “pro-grade research through Claude Code” is usually hybrid

  • [Recommended conclusion]
    • Let Claude Code orchestrate coding and synthesis.
    • Give it MCP search + extraction tools.
    • Use Perplexity Pro/Max for human-led parallel research when the topic is broad or executive-facing.
    • Use Codex as a second-opinion checker if already available.

E. Do not overbuy tools before proving the workflow

  • [Verified in part; community-supported in part] Tool sprawl creates context overhead and operational noise. Start lean. [R8][R21][C1][C2]

Reasoning, Tradeoffs, and Why It Matters

1) Why Claude Code alone can feel weak for deep research

  • [Reasoned inference] Claude Code is fundamentally a coding agent with tool access, not a turnkey research product with a proprietary research UI and heavily optimized retrieval stack.
  • [Verified support] Dedicated providers such as Perplexity, Exa, Tavily, Firecrawl, and Brave each expose specialized search / fetch / extraction / research functions. [R23][R25][R27][R29][R32]
  • Practical meaning: if the user needs consistently high-quality current research, Claude Code usually performs better when backed by specialized MCP tools rather than forced to do everything with browser automation or its default capabilities.

2) Human-led research vs agentic backend research

  • Human-led research seat: best for exploratory investigation, report drafting, hypothesis generation, and “search the world for me” style questions.
    • Best fits: Perplexity Pro / Max
  • Agentic backend research: best for programmatic, repeatable, cost-aware research inside Claude Code workflows.
    • Best fits: Exa MCP, Tavily MCP, Firecrawl, Brave Search API/MCP
  • Second-opinion engine: best for checking or triangulating results.
    • Best fit if already owned: Codex

3) Predictable subscription spend vs pay-as-you-go

  • Most predictable: Tavily monthly plans; Firecrawl monthly subscription
  • Moderately predictable: Perplexity Pro / Max (for human seat only, not backend automation)
  • Variable / usage-based: Exa API, Brave Search API, Perplexity API
  • Lowest-friction test path: Exa remote MCP (no API key required), then add a key if free limits become a bottleneck

4) Where Fireflies fits

  • Best case: you already want Fireflies for meeting intelligence, searchable transcripts, and AI summaries; the Perplexity Pro year becomes a genuinely useful bonus.
  • Bad case: you buy Fireflies mainly to get Perplexity and then expect it to power Claude Code research for free. That expectation is wrong.

Recommended Playbook / Process

Phase 1 — Audit what is actually active

  1. [Verified recommendation] In Claude Code, inspect:

    • /mcp
    • /permissions
    • /chrome
    • /config [R2][R4][R8]

  2. Check these files/scopes:

    • ~/.claude/settings.json
    • ~/.claude/CLAUDE.md
    • .claude/settings.json
    • .claude/settings.local.json
    • .mcp.json [R4]

  3. Determine whether Claude.ai MCP servers are flowing in automatically.
    If needed, launch with:

ENABLE_CLAUDEAI_MCP_SERVERS=false claude
  • [Verified] That environment variable disables synced Claude.ai MCP servers in Claude Code. [R8][R21]

Phase 2 — Decide the operating mode

If you want local tools/config but browser/mobile access

Use Remote Control.

  • [Verified] This preserves local filesystem, local MCP servers, and project configuration. [R13]

If you want cloud web sessions

Accept that:

  • user-level local settings do not carry over,
  • setup scripts and repo-level hooks matter more,
  • plugins are not available for remote sessions. [R14][R15]

Phase 3 — Force browser to become optional

Minimum viable hardening

  • Set browser tools to Ask or Deny in /permissions.
  • If needed, add a PreToolUse hook that blocks browser tools unless certain conditions are met. [R4][R6]

Example policy language for CLAUDE.md

Use ~/.claude/CLAUDE.md for global guidance:

# Research Policy
 
For external research:
1. Prefer MCP search tools first.
2. Prefer fetch/extract/crawl tools second.
3. Use browser automation only when:
   - authentication is required,
   - the content is JS-heavy and non-browser retrieval failed,
   - or an interactive workflow must be tested.
4. If browser is used, explain why it was necessary.
5. Keep searches sequential unless explicitly told to parallelize.
6. Distinguish facts from inference and cite sources.
  • [Verified] CLAUDE.md is appropriate for this kind of persistent guidance, but it is not hard enforcement. [R3][R4]

Phase 4 — Add one research skill

Why

  • Teaches the preferred sequence
  • Gives the model better discoverability
  • Makes manual invocation easy
  • Name: research-first
  • Manual-only at first (disable-model-invocation: true)
  • Use MCP search → extract → browser fallback
  • Require source citation and explanation of browser use

Example skeleton

---
name: research-first
description: Use for external research. Search with MCP tools first, then fetch/extract, and use browser only when auth, JS rendering, or interactivity makes it necessary.
disable-model-invocation: true
context: fork
agent: Explore
---
 
Research $ARGUMENTS thoroughly.
 
Required workflow:
1. Search with MCP tools first.
2. Retrieve page content with extraction/crawl tools second.
3. Use browser tools only as a fallback.
4. State why browser was required if you use it.
5. Prefer official sources where possible.
6. Distinguish facts, inference, and uncertainty.
7. Return citations and concise evidence notes.
  • [Verified] These skill fields and patterns are supported by Anthropic. [R5]

Phase 5 — Choose the research backend

Best low-friction stack

Exa MCP + Firecrawl

  • Why:
    • Exa MCP is free to test and does not require an API key for the remote MCP path. [R25]
    • Firecrawl provides strong crawl/extract and explicitly recommends its skill for agent discovery. [R27][R28]

Best simple predictable subscription stack

Tavily + Firecrawl

  • Why:
    • Tavily has transparent monthly pricing and search/extract pattern support. [R29][R31][R39]
    • Firecrawl gives stronger extraction and browser-like scraping depth when needed. [R27][R40]

Best classic search stack

Brave + Firecrawl

  • Why:
    • Brave brings a classic independent index with simple request economics and official skills. [R23][R24][R41]
    • Firecrawl handles page retrieval and structured scrape workflows. [R27][R28]

Phase 6 — Decide what to do about Perplexity

If you can get Perplexity Pro free via Fireflies and you will actually use Fireflies

Recommendation: yes, claim it.

  • Good use:
    • human-led deep research
    • report drafting
    • quick parallel source triangulation
    • executive-facing answer generation
  • Bad use:
    • expecting it to eliminate API spend for Claude Code MCP workflows

If you are buying a plan specifically for agentic backend research inside Claude Code

Recommendation: do not buy Perplexity Pro for that reason alone. Instead:

  • use Exa/Tavily/Brave/Firecrawl for the backend
  • optionally use Perplexity Pro as a side-seat only if you value the human interface

If you are a genuine power user living inside Perplexity

Consider Perplexity Max, not just Pro.

  • [Verified] Max increases product-side research/query limits and access, but that still does not include API usage. [R32][R34a]

Phase 7 — Put Codex to work before adding more subscriptions

If Codex is already available:

  • use Codex as a parallel verifier
  • use its default cached web search for cheaper/safer verification passes
  • keep Claude Code as the orchestrator and synthesis layer

Suggested pattern:

  1. Claude Code gathers via MCP tools.
  2. Codex checks a subset of critical claims.
  3. Claude produces the final synthesis.
  • [Partially verified / recommended] This is technically consistent with current docs, but the exact operational glue still needs proving in the user’s environment. [R16][R17][R18][R20]

Subscription / Spend Strategy

Recommendation hierarchy

Tier 1 — best immediate value

  • Claim Perplexity Pro via Fireflies if eligible
  • Install Exa MCP
  • Add a research skill
  • Gate browser tools
  • Use Codex as verifier

Why: minimal incremental spend, high immediate improvement.

Tier 2 — best predictable backend stack

  • Tavily monthly plan
  • Firecrawl paid plan if extraction volume matters
  • Keep Perplexity Pro as human seat only

Why: predictable monthly budgeting for research-intensive work.

Tier 3 — power-user / heavier research org setup

  • Perplexity Pro or Max for human-led research
  • Exa or Tavily as primary search backend
  • Firecrawl for deep extraction
  • Codex parallel checker
  • Hooks for enforcement

Why: this is the closest to a “professional research workstation” setup.

Anthropic / Claude Code

  • Claude Code overview and architecture
  • Chrome integration
  • Memory / CLAUDE.md
  • Permissions
  • Settings scopes
  • Skills
  • Hooks
  • MCP
  • Desktop / VS Code / Remote Control / cloud web docs

Perplexity

  • MCP server docs
  • Search API docs
  • plan comparison
  • API billing
  • credits
  • promotions

Search / extraction providers

  • Exa MCP, skills, pricing
  • Tavily MCP, skills, pricing
  • Firecrawl MCP, skill recommendation, billing
  • Brave Search API, pricing, official skills

OpenAI / Codex

  • Codex config basics
  • Codex MCP server
  • AGENTS.md
  • Codex skills

Risks, Caveats, and Red Flags

  • [Verified] Third-party MCP servers can expose you to prompt injection and should be treated as untrusted. [R8]
  • [Verified] Browser tools consume more context when always enabled. [R2]
  • [Verified] CLAUDE.md is not policy enforcement. [R3]
  • [Verified] Plugins are not available for remote sessions. [R14]
  • [Verified] Perplexity promotional access requires a payment method and can auto-renew if not cancelled. [R36]
  • [Verified] Firecrawl credits do not roll over and paid use is subscription-based rather than pure pay-as-you-go. [R40]
  • [Community-reported] Tool overload, duplicated loading, and silent MCP/connectors can materially damage context efficiency. [C1][C2]
  • [Community-reported] Hooks are powerful but not magically foolproof; sandboxing and cautious permissions still matter. [C3][C4]

Open Questions / What Still Needs Verification

  1. [Open] Which exact Claude surface is the user relying on most right now?

    • local CLI,
    • VS Code,
    • cloud web sessions,
    • Remote Control,
    • or a mix?

  2. [Open] Which browser capability is actually active?

    • Chrome enabled by default?
    • VS Code Chrome extension?
    • Browser MCP from a plugin?

  3. [Open] Which MCP servers are currently installed or inherited from Claude.ai?

    • This matters because hidden tools may be driving the behavior.

  4. [Open] Is the Fireflies → Perplexity offer currently visible and redeemable in the user’s Fireflies dashboard?

    • The partnership is officially documented, but this memo did not validate the user’s specific account eligibility state.

  5. [Open] What are the exact free-plan/rate-limit boundaries for the user’s realistic Exa MCP use?

    • Exa says the MCP has a generous free plan and no API key is required for the remote MCP path, but the precise practical threshold for this user’s workload still needs testing. [R25]

  6. [Open] Is Codex worth integrating as an MCP-backed subordinate research engine in practice, or is it simpler to use it as a separate window / second-opinion process?

    • Technically plausible either way; operationally unverified here.

  7. [Open] Does the user want a primarily:

    • human-led research workflow,
    • agentic backend workflow,
    • or hybrid?
    • This changes the ideal spend mix materially.

Suggested Next Steps

Immediate

  1. Run an audit in Claude Code:

    • /mcp
    • /permissions
    • /chrome
    • /config

  2. Add or update:

    • ~/.claude/CLAUDE.md
    • browser Ask/Deny rule
    • one manual research-first skill

  3. Install Exa MCP first.

    • It is the lowest-friction test path because the remote MCP path is documented as not requiring an API key. [R25]

  4. If extraction quality is still weak, add Firecrawl next.

This week

  1. Claim the Fireflies / Perplexity Pro offer if:

    • you already want Fireflies,
    • or you can obtain it at lower total cost than Perplexity directly,
    • and you will actually use Perplexity as a human research seat.

  2. Use Perplexity Pro in parallel with Claude Code for a few real research tasks and observe:

    • whether it meaningfully improves the research outcome,
    • whether it reduces browser thrashing,
    • and whether it becomes a regular part of the workflow.

  3. Use Codex as a parallel verifier on a couple of research-heavy tasks before buying more tools.

After validation

  1. If Claude still overuses browser tools, add a PreToolUse hook to block browser usage unless a short whitelist of reasons applies.

  2. Keep the stack small until there is clear evidence of need.

Handoff Notes for Another AI

What the user is trying to achieve

The user wants a pro-grade research workflow for Claude Code / cloud co-work that avoids wasteful browser-first behavior and performs better on serious research tasks. They are open to:

  • skills,
  • hooks,
  • MCP servers,
  • subscription products,
  • and using Codex as part of the stack.

What has already been established

  • The browser-heavy default is undesirable.
  • Skills are helpful but not the main enforcement layer.
  • Permissions and hooks are the stronger control points.
  • Perplexity Pro is useful as a product seat but does not include API backend usage for Claude Code.
  • Fireflies’ partnership may make Perplexity Pro economically attractive, but only as a product seat, not an API subsidy.
  • Exa, Tavily, Firecrawl, and Brave are the main backend candidates worth considering.
  • Remote Control matters if the user wants browser/mobile access while keeping local tools.

Likely best next operational move

Help the user create:

  1. a global CLAUDE.md,
  2. a research-first skill,
  3. a browser Ask/Deny permissions rule,
  4. and an MCP configuration starting with Exa, optionally followed by Firecrawl.

Do not assume

  • that the repo alone controls tool behavior,
  • that Perplexity Pro solves API costs,
  • that plugins will work in remote/cloud contexts,
  • or that Codex-to-Claude integration is already turnkey.

Preferred communication style for this user

  • structured,
  • highly actionable,
  • explicit about tradeoffs,
  • honest about uncertainty,
  • and oriented toward building a lean but powerful operator stack.

Reviewer Notes and Improvements Made

Self-review performed. No separate reviewer agent was available.

Problems corrected from earlier discussion

  1. Earlier discussion risked overstating skills as the main lever.
    Improvement made: clarified that skills are useful but permissions/hooks are the harder controls. [R3][R4][R5][R6]

  2. Earlier discussion risked implying that Perplexity Pro might cleanly power Claude Code research.
    Improvement made: separated product subscription vs API billing and explicitly documented that API access is separately billed. [R32][R33]

  3. Earlier discussion did not sufficiently separate local, remote-control, and cloud web modes.
    Improvement made: added a dedicated mode comparison using official Anthropic docs. [R13][R14][R15]

  4. Earlier discussion did not fully resolve the Fireflies / Perplexity plan question.
    Improvement made: verified the official promotion, current Fireflies pricing, Perplexity plan distinctions, and the limits of what the promo changes economically. [R34][R35][R36][R37]

  5. Earlier discussion did not give enough economic framing.
    Improvement made: added a spend strategy and subscription recommendation hierarchy.

Remaining limitations

  • Some provider free-tier practical limits still need real-world testing.
  • Community-reported patterns are included, but clearly labeled as anecdotal/community material rather than verified product behavior.

Optional Appendix — Structured Summary

title: Claude Code Research Stack, Browser-Last Configuration, and Subscription Strategy
date: 2026-03-15
user_goal:
  - reduce browser-first research behavior in Claude/cloud co-work
  - achieve pro-grade research quality
  - understand whether skills, Perplexity Pro, Fireflies promo, MCP tools, and Codex are worth using
core_findings:
  - status: Verified
    point: CLAUDE.md is context, not enforced policy
  - status: Verified
    point: permissions can allow/ask/deny tools
  - status: Verified
    point: PreToolUse hooks can deny tool calls
  - status: Verified
    point: synced Claude.ai MCP servers may appear automatically in Claude Code
  - status: Verified
    point: Chrome can be enabled by default and is available in VS Code with the extension
  - status: Verified
    point: Perplexity product plans and API billing are separate
  - status: Verified
    point: Fireflies offers a one-year Perplexity Pro promo to Pro/Business users
  - status: Partially verified
    point: Codex can help as verifier or MCP server, but turnkey Claude->Codex research backend remains unproven here
recommended_stack:
  human_research_seat:
    - Perplexity Pro if free via Fireflies or otherwise clearly worth it
  claude_backend:
    - Exa MCP first
    - Firecrawl second if extraction depth is needed
  controls:
    - browser ask/deny permissions
    - research-first skill
    - hook only if needed
  verifier:
    - Codex
open_questions:
  - which Claude surface is primary
  - which MCP servers are currently active
  - whether Fireflies promo is redeemable on the user's account
  - whether Exa free MCP limits are sufficient for the real workload

References

Official / primary sources

Community / user-reported sources

Graph View