AI Engineer · Published 2026-10-02

MCP Doesn't Suck. Your Agent Does. — Jan Čurn, Apify

privateReview: unreviewedConfidence: high
MCPmcpccliagentscontextapifycontext-windowprogressive-disclosurecode-modeSub-agentsagent-harness
Open on YouTube ↗

Summary

Overview

  • Speaker: Jan Čurn
  • Channel: AI Engineer
  • Main topic: Evaluating and improving Model Context Protocol (MCP) usage with agents by combining MCP with CLI approaches (MCPC).
  • Purpose: Explain why agents struggle with MCP, analyze existing solutions, and introduce mcpc as a universal CLI client combining MCP and CLI strengths. Jan Čurn, founder and CEO of Apify, addresses the hate and criticism directed at the Model Context Protocol (MCP) over the past year. He argues that the protocol itself is not flawed; rather, the naive harness implementations used by most AI agents are to blame. Agents frequently load all available MCP tools and their results directly into the context window, causing token bloat, loss of accuracy, and high costs. To solve this, Čurn introduces three solutions: sub-agents, progressive tool discovery, and code mode, and presents 'mcpc', a universal CLI client for MCP developed by Apify that implements progressive tool discovery, asynchronous tasks, JSON output, and x402 payments.

Topic Map

The State of MCP and Backlash

  • Explanation: MCP became immensely popular last year as a standard for agent-to-tool interaction, but quickly faced heavy criticism and complaints from developers claiming MCP is the wrong abstraction or dead in the water.
  • Key claims:
    • MCP became the darling of the AI world with thousands of servers built.
    • A wave of criticism emerged claiming MCP eats too much context and CLIs are better.
  • Examples:
    • Tweets from developers stating 'MCP is a mistake. Long live CLIs' and 'MCPs are mostly useless'.
  • Terminology:
    • Model Context Protocol (MCP)
    • MCP Registry
  • Why it matters: Highlights the industry tension between protocol-based tool access and traditional CLI/API usage.

The Core Problem: Harness Inefficiency

  • Explanation: The primary issue with MCP is not the protocol specification, but how agent harnesses load tools and context.
  • Key claims:
    • Most agents load all MCP tools and their results directly into the context window right away.
    • Uncontrolled context growth leads to reduced accuracy and higher costs.
  • Examples:
    • Loading 10 MCP servers with 10 tools each consumes a massive fraction of the context window before any work is done.
  • Terminology:
    • Harness
    • Context window
    • Token bloat
  • Why it matters: Clarifies that blaming the MCP protocol is misguided; harness architecture needs improvement.

Solutions to Context Bloat

  • Explanation: Three main solutions have emerged to combat context consumption: sub-agents, progressive tool discovery, and code mode.
  • Key claims:
    • Solution 1: Splitting context into sub-agents helps isolate tasks, but still incurs token costs and retains sensitive data in context.
    • Solution 2: Progressive tool discovery (like tool search tool) loads tools only when needed, saving massive amounts of context.
    • Solution 3: Code mode treats tools as code rather than functions, leveraging LLMs' strong code generation and navigation capabilities.
  • Examples:
    • Anthropic and Cursor introducing tool search tool and code mode.
  • Terminology:
    • Sub-agents
    • Progressive tool discovery
    • Code mode
  • Why it matters: Provides architectural patterns for developers building agent harnesses.

Why CLIs Outperform Naive MCP Clients

  • Explanation: CLIs naturally handle context efficiently because agents never load a full CLI and its docs into context at once; instead, they use progressive tool discovery via help commands and execute shell commands.
  • Key claims:
    • Agents never load full CLIs into context; they load them progressively.
    • Models know the Unix shell and CLI patterns deeply from extensive training data.
    • CLIs remain a local black box lacking standard auth and transport protocols.
  • Examples:
    • Using bash help commands or basic Linux shell utilities.
  • Terminology:
    • CLI
    • Shell
    • Sandbox
  • Why it matters: Demonstrates why developers lean towards CLIs and how MCP can adopt CLI advantages.

Introducing MCPC: The Universal CLI Client for MCP

  • Explanation: Apify built 'mcpc' as a universal CLI client for MCP that encapsulates full MCP complexity behind standard bash tool calls.
  • Key claims:
    • mcpc provides full MCP support and compatibility (tasks, resources, prompts, logging).
    • It is lightweight with minimal dependencies and no LLM built-in.
    • It supports code mode with --json flags and agentic payments via x402.
  • Examples:
    • Running npx @apify/mcpc or bun install -g @apify/mcpc, logging in via OAuth, and connecting to filesystem or Apify MCP servers.
  • Terminology:
    • mcpc
    • x402
    • Asynchronous tasks
    • OAuth profiles
  • Why it matters: Bridges the gap between MCP's remote capabilities and CLI's interface simplicity.

Connector Evaluations and Benchmarks

  • Explanation: Apify built a new benchmarking framework called connector-evals to compare raw MCP, mcpc, and native CLIs across various tasks.
  • Key claims:
    • mcpc and CLI performance are very comparable in cost and time benchmarks.
    • Raw MCP sometimes finishes tasks faster but consumes more tokens.
  • Examples:
    • Cross-actor-meta-and-repo-test benchmarks comparing cumulative cost vs time.
  • Terminology:
    • connector-evals
    • Benchmark
    • Cumulative cost
  • Why it matters: Provides empirical data on the trade-offs between different agent tool-calling wrappers.

Key Points

MCP doesn't suck; agent harnesses do

  • Explanation: The protocol specification is robust, but naive client implementations overload the context window with all available tools.
  • Evidence: Analysis of context window consumption showing over 60-95% free space differences when using progressive tool search.
  • Practical implication: Developers must implement progressive tool loading in their agent harnesses rather than dumping all tool schemas into system prompts.

CLIs succeed because of progressive discovery and shell familiarity

  • Explanation: Models are trained extensively on shell commands and explore command-line tools incrementally via help documentation.
  • Evidence: Linux shell history dating back to 1969 optimized characters and documentation for concise human and AI interaction.
  • Practical implication: Agent interfaces should mimic shell behavior and progressive execution.

MCPC bridges remote MCP power with CLI simplicity

  • Explanation: By wrapping MCP servers in a CLI client (mcpc), agents can interact with remote MCP capabilities using a single familiar tool call (bash).
  • Evidence: Live terminal demonstrations showing session persistence, grep search, async task execution, and OAuth login.
  • Practical implication: Agents can use MCP servers without managing complex sessions, authorization, or transport protocols directly.

Frameworks, Models & Processes

mcpc (Model Context Protocol Client)

  • How it works: Acts as a lightweight CLI wrapper over the MCP protocol, exposing commands like connect, session, grep, tools-call, tasks, and resources with full JSON output formatting.
  • Components:
    • Session management
    • Progressive tool discovery (grep)
    • Code mode (--json flag)
    • Agentic payments (x402)
    • MCP proxy for sandboxing
  • When to use: When building AI agents that need secure, standardized remote tool access via simple shell commands.

Connector Evals

  • How it works: A benchmarking framework to evaluate the performance and token costs of different agent connectors (raw MCP, mcpc, CLI).
  • Components:
    • Test scenarios (cross-actor-meta, repo tests)
    • Time tracking
    • Cumulative cost calculation in USD
  • When to use: When comparing the efficiency and cost-effectiveness of various agent tool integration strategies.

Examples & Case Studies

Connecting mcpc to filesystem (fs) and Apify MCP servers via bash commands.

  • Illustrates: How an agent interacts with local and remote MCP servers through a single bash tool call.
  • Lesson:

Running mcpc grep 'find' during the live demo.

  • Illustrates: Progressive tool discovery where only relevant tools matching the search string are surfaced.
  • Lesson: Saves significant context window space by avoiding loading irrelevant tool definitions.

Actionable Takeaways

  • Immediate:
    • Install mcpc using npm install -g @apify/mcpc or bun install -g @apify/mcpc.
    • Use progressive tool discovery and code mode patterns in agent design.
    • Leverage --json flags in CLI tools to compose tool calls with jq.
  • Strategic:
    • Combine MCP for standard remote access with CLI interfaces for local agent interaction.
    • Avoid loading all tool definitions into context simultaneously.
    • Support asynchronous tasks and agentic payments (x402) in agent toolchains.
  • Questions to investigate:
    • How do different LLM models perform when shifting from function calling to code mode?
    • What are the security implications of exposing arbitrary CLI commands in agent harnesses?

Claims Worth Verifying

  • MCP was introduced by Anthropic about two years ago. (historical fact)
  • mcpc supports agentic payments via x402. (technical capability)

Notable Quotes

"MCP is a standard to securely access tools and resources, right? Basically standard for agent to tool interaction." (at 0:41) "So when MCP connects agents with tools, everybody loves MCP, right? Right? Well, not exactly." (at 2:08) "MCP eats too much context. And actually, that's true." (at 3:56) "So, stop saying CLI is better than MCP, because MCP plus CLI is the best." (at 30:18)

Compressed Summary

  • MCP criticism stems from poor agent harness design, not protocol flaws.
  • Naive agents loading all tool schemas cause massive context bloat and high costs.
  • Solutions include sub-agents, progressive tool discovery, and code mode.
  • mcpc is Apify's universal CLI client for MCP featuring full protocol support, JSON output, and x402 payments.
  • Keywords: mcp, mcpc, cli, agents, context, apify
  • Core insight: MCP is not flawed; agents fail because harnesses naively load all tool definitions into context, which can be fixed by combining MCP with CLI progressive discovery patterns using tools like mcpc.

Core insights

7
Mental Modelmedium noveltystrong evidence

The MCP backlash is misattributed: the protocol spec is not the problem, the harness is. Naive harnesses eagerly load every tool schema and result into the context window before any work happens, so context exhaustion is an architectural defect of the client, not the wire protocol.

Why it matters

Shifts the fix from 'abandon MCP for CLIs' to 'fix tool-loading architecture', which is a much cheaper and more general intervention for anyone maintaining an agent harness or MCP client.

Generalization

When a tooling standard is perceived as bad, check whether the failure is in the protocol or in the eager-loading behavior of its default consumer.

The primary issue with MCP is not the protocol specification, but how agent harnesses load tools and context.
Open source video
Most agents load all MCP tools and their results directly into the context window right away.
Open source video
Loading 10 MCP servers with 10 tools each consumes a massive fraction of the context window before any work is done.
Open source video
Empirical Resultmedium noveltymoderate evidence

Progressive tool discovery (a tool-search tool that loads tools only on demand) reclaims a large fraction of the context window — the summary cites 60–95% free-space differences versus eager loading.

Why it matters

Quantifies the payoff of on-demand tool schema retrieval, making it a concrete lever for cost and accuracy rather than a vague best practice.

Generalization

Tool schemas and capability docs should be retrieved lazily like a search index, not inlined into the system prompt.

Progressive tool discovery (like tool search tool) loads tools only when needed, saving massive amounts of context.
Open source video
Analysis of context window consumption showing over 60-95% free space differences when using progressive tool search.
Open source video
Mechanismhigh noveltymoderate evidence

Code mode reframes tools as code rather than as callable functions, exploiting LLMs' strong code generation and navigation ability instead of relying on structured function-calling schemas.

Why it matters

Changes the abstraction boundary between agent and tool: the model writes/reads code against tools, which can collapse many function-call round-trips into a single code artifact.

Generalization

Where the model is strongest (code), express the tool interface in that medium rather than in a schema format optimized for the host language.

Solution 3: Code mode treats tools as code rather than functions, leveraging LLMs' strong code generation and navigation capabilities.
Open source video
Anthropic and Cursor introducing tool search tool and code mode.
Open source video
Mental Modelmedium noveltymoderate evidence

CLIs already behave like a progressive-discovery agent interface: agents never load a whole CLI or its docs at once, they explore incrementally via help/search, and models have deep prior training on Unix shell patterns and 1969-era conventions designed for terse input.

Why it matters

Explains the CLI advantage as a structural property (lazy discovery + training prior), not aesthetics, so MCP/agent tooling can deliberately adopt those properties.

Generalization

Interface designs that match a model's pretraining distribution and support incremental discovery will outperform richer but eagerly-loaded alternatives.

Agents never load full CLIs into context; they load them progressively.
Open source video
Models know the Unix shell and CLI patterns deeply from extensive training data.
Open source video
Linux shell history dating back to 1969 optimized characters and documentation for concise human and AI interaction.
Open source video
Architecturehigh noveltymoderate evidence

Wrapping MCP servers in a CLI client (mcpc) reduces the agent-facing surface to a single familiar bash tool call, while the client absorbs MCP complexity — sessions, OAuth profiles, resource/prompt/logging support, async tasks — behind standard commands with JSON output.

Why it matters

Moves session management, authorization, and transport handling out of the agent's reasoning context into a deterministic client, which should reduce context cost and tool-call error surface.

Generalization

Put protocol complexity in a thin deterministic adapter and expose one already-known interface (shell) to the model, rather than teaching the model the protocol.

mcpc provides full MCP support and compatibility (tasks, resources, prompts, logging).
Open source video
mcpc and CLI performance are very comparable in cost and time benchmarks.
Open source video
It supports code mode with --json flags and agentic payments via x402.
Open source video
Tradeoffmedium noveltymoderate evidence

Benchmark evidence from connector-evals shows three wrappers trading off differently: mcpc and native CLI are comparable on cost and time, while raw MCP sometimes finishes faster but at higher token consumption.

Why it matters

Suggests there is no single dominating tool-access strategy — latency-sensitive workloads may prefer raw MCP, cost-sensitive ones the CLI/mcpc path — so wrapper choice should be workload-driven and measured.

Generalization

Token cost and wall-clock latency are separable axes for tool interfaces; optimize and benchmark them independently.

mcpc and CLI performance are very comparable in cost and time benchmarks.
Open source video
Raw MCP sometimes finishes tasks faster but consumes more tokens.
Open source video
Cross-actor-meta-and-repo-test benchmarks comparing cumulative cost vs time.
Open source video
Failure Modemedium noveltymoderate evidence

Sub-agent decomposition isolates task context but does not eliminate the underlying costs: it still incurs token spend and can retain sensitive data inside context.

Why it matters

Cautions against treating sub-agents as a clean fix for context bloat; they mitigate interference but not token economy or data-exposure risk.

Generalization

Context isolation and context minimization are distinct goals; an isolation strategy is not automatically a minimization or privacy strategy.

Solution 1: Splitting context into sub-agents helps isolate tasks, but still incurs token costs and retains sensitive data in context.
Open source video

Deep dives

5

Accuracy vs cost gains from progressive tool discovery

Research question

Does progressive tool discovery improve task accuracy beyond cost savings, or are its benefits purely token-economical?

Why

If accuracy improves, progressive discovery becomes a performance lever; if only cost, it's an efficiency optimization. This determines adoption priority.

Progressive tool discovery (like tool search tool) loads tools only when needed, saving massive amounts of context.
Open source video
Analysis of context window consumption showing over 60-95% free space differences when using progressive tool search.
Open source video
Source video

Workload characterization for raw MCP vs CLI/mcpc

Research question

For which task types, tool counts, and server counts does raw MCP's lower latency outweigh its higher token consumption compared to CLI/mcpc?

Why

Enables workload-driven selection of tool-access strategy, avoiding one-size-fits-all prescriptions.

Raw MCP sometimes finishes tasks faster but consumes more tokens.
Open source video
mcpc and CLI performance are very comparable in cost and time benchmarks.
Open source video
Source video

mcpc fidelity to MCP behavioral surface

Research question

Does mcpc's bash-wrapper design preserve the full behavioral surface of MCP (async tasks, resources, prompts, logging) without leaking protocol complexity back to the agent?

Why

Critical for trusting mcpc as a general MCP client; any fidelity gaps could break real-world agent workflows.

mcpc provides full MCP support and compatibility (tasks, resources, prompts, logging).
Open source video
It supports code mode with --json flags and agentic payments via x402.
Open source video
Source video

Containment of sensitive data in sub-agent contexts

Research question

What concrete mechanisms (redaction, scoping, ephemeral contexts) measurably reduce sensitive-data persistence across sub-agent boundaries?

Why

Sub-agents are often proposed for isolation, but without containment they remain a privacy risk.

Splitting context into sub-agents helps isolate tasks, but still incurs token costs and retains sensitive data in context.
Open source video
Source video

Isolating CLI advantage: progressive discovery vs shell pretraining

Research question

Is the CLI advantage over naive MCP agents attributable to progressive discovery, shell pretraining, or both, and can they be isolated experimentally?

Why

If shell pretraining is a major factor, then non-CLI interfaces might not benefit equally from progressive discovery; this affects tool interface design.

Agents never load full CLIs into context; they load them progressively.
Open source video
Models know the Unix shell and CLI patterns deeply from extensive training data.
Open source video
Source video

Article ideas

4

MCP Doesn't Suck: Your Harness Does

The widespread criticism of MCP stems from naive harness implementations that eagerly load all tool schemas and results, not from flaws in the protocol. Fix the loading architecture and MCP becomes viable again.

Angle

Reframing the debate from protocol vs CLI to harness design, with concrete architectural patterns.

Source video

Progressive Tool Discovery: The 60–95% Context Win You're Missing

Lazy tool-schema retrieval is not just an optimization; it is the single highest-leverage change to reclaim context and reduce cost, and should be the default in agent harnesses.

Angle

Quantifying context savings and arguing for on-demand tool search as a standard.

Source video

Code Mode: Stop Calling Tools, Start Writing Code

Treating tools as code rather than callable functions exploits LLMs' strongest capability—code generation—and collapses round-trips, but requires safe execution sandboxes.

Angle

Why code mode is a superior abstraction and what it demands from harnesses.

Source video

Sub-Agents Are Not a Privacy Fix

Sub-agent decomposition isolates tasks but does not minimize token costs or sensitive data exposure; without explicit containment, it can create a false sense of security.

Angle

Distinguishing isolation from minimization and calling for concrete redaction/scoping mechanisms.

Source video

Project ideas

4

Progressive vs Eager Tool Loading Benchmark

beyond-evals

Progressive tool discovery yields higher task accuracy than eager loading on complex tasks with many tools, not just lower token cost.

Proof of concept

Implement two harness variants: one eager-loads all tool schemas, one uses on-demand search. Run identical task suites from connector-evals with varying tool counts (10, 50, 100).

Measurement

Task success rate, token consumption, and wall-clock time per task; correlation between context free space and accuracy.

Source video

Cost-Latency Pareto Frontier for Tool Access Wrappers

beyond-evals

There exists a workload-dependent crossover where raw MCP's lower latency justifies its higher token cost, and this crossover can be predicted by task type and tool count.

Proof of concept

Benchmark raw MCP, mcpc, and native CLI across tasks varying in tool count, server count, and latency sensitivity. Plot cost vs time Pareto frontiers.

Measurement

Token cost, wall-clock latency, and task success; identify Pareto-optimal wrapper per workload class.

Source video

mcpc Adversarial Fidelity Tester

movement-lab

mcpc preserves full MCP behavioral surface (async tasks, resources, prompts, logging) without leaking protocol details to the agent, matching native MCP client fidelity.

Proof of concept

Build a test suite of MCP servers exercising streaming, long-running tasks, resources, prompts, and logging. Run agent tasks via mcpc and native MCP client; compare feature coverage and agent token overhead.

Measurement

Feature coverage percentage, agent token usage for protocol mechanics, failure rates on edge cases.

Source video

Sensitive Data Persistence in Sub-Agent Contexts

gatehouse

Explicit scoping and redaction policies measurably reduce sensitive-data persistence across sub-agent boundaries compared to naive sub-agent splitting.

Proof of concept

Create a multi-step task where a sub-agent processes sensitive data (e.g., credentials, PII). Compare three conditions: no sub-agents, naive sub-agents, sub-agents with scoped contexts and redaction. Measure leakage.

Measurement

Rate of sensitive data appearing in subsequent contexts or logs; token cost; task success.

Source video

Architectural implications

4

Tool schema delivery to the model

Before

All MCP tool schemas are inlined into the system prompt/context at agent start.

After

Tools are discoverable on demand via search/grep and loaded only when relevant.

Consequence

Large context savings (cited 60–95% free-space differences) and fewer distractors, at the cost of an extra discovery step per task.

Source video

Where protocol concerns live

Before

The agent directly manages MCP sessions, transport, and authorization.

After

A thin CLI client (mcpc) owns sessions, OAuth profiles, resources, and transport; the agent only issues bash calls.

Consequence

Smaller agent-facing interface and fewer context tokens spent on protocol mechanics, but adds a dependency between agent and adapter.

Source video

Tool invocation medium

Before

Structured function-call schema per tool invocation.

After

Code mode: the model writes/reads code that uses tools, with JSON output flags.

Consequence

Fewer round-trips and better use of code-generation strength; requires the harness to safely execute generated code.

Source video

Task decomposition boundary

Before

Single agent context accumulates all intermediate state.

After

Sub-agents isolate sub-task context.

Consequence

Reduced interference between tasks, but token costs and sensitivity of retained data persist.

Source video

Tradeoffs and failure modes

4

Raw MCP vs CLI/mcpc wrappers

Benefit

Raw MCP sometimes finishes tasks faster.

Cost or risk

It consumes more tokens, raising cost and context pressure.

Raw MCP sometimes finishes tasks faster but consumes more tokens.
Open source video
Source video

Sub-agent context splitting

Benefit

Helps isolate tasks and limit cross-task interference.

Cost or risk

Still incurs token costs and retains sensitive data in context.

Splitting context into sub-agents helps isolate tasks, but still incurs token costs and retains sensitive data in context.
Open source video
Source video

CLI-style tool access

Benefit

Progressive discovery and strong shell priors keep context small and calls familiar.

Cost or risk

CLIs remain a local black box lacking standard auth and transport protocols.

CLIs remain a local black box lacking standard auth and transport protocols.
Open source video
Source video

Progressive tool discovery

Benefit

Loads tools only when needed, saving massive amounts of context.

Cost or risk

Introduces a discovery/search step before the tool can be invoked (implied by the on-demand model).

Progressive tool discovery (like tool search tool) loads tools only when needed, saving massive amounts of context.
Open source video
Source video

Open questions

4

Does the 60–95% context free-space difference from progressive tool discovery translate into measurable accuracy gains, or only cost savings?

Why unresolved

The summary reports context consumption differences but gives no downstream accuracy or task-success numbers.

Research direction

Run connector-evals-style benchmarks that hold task constant and vary tool-loading strategy, reporting both token cost and success rate.

Source video

For which workloads does raw MCP's lower latency outweigh its higher token consumption?

Why unresolved

The benchmark result is stated qualitatively ('sometimes finishes faster'); no crossover threshold or workload characterization is given.

Research direction

Characterize cost-vs-time Pareto frontiers by task type, tool count, and server count to find where each wrapper wins.

Source video

Does mcpc's bash-wrapper design preserve the full behavioral surface of MCP (async tasks, resources, prompts, logging) without leaking protocol complexity back to the agent?

Why unresolved

The summary lists claimed features and demo observations but provides no failure or fidelity analysis.

Research direction

Adversarially exercise mcpc against MCP servers that rely on streaming, long-running tasks, and prompts, and measure feature coverage and agent token overhead.

Source video

Given that sub-agents still retain sensitive data in context, what concrete containment mechanism (redaction, scoping, ephemeral contexts) actually reduces exposure?

Why unresolved

The summary flags the risk but offers no mitigation.

Research direction

Design experiments measuring sensitive-data persistence across sub-agent boundaries and test scoped-context or redaction policies.

Source video

Key claims

7
causalVerification needed

MCP's problems stem from naive harness implementations that eagerly load all tools and results into context, not from the protocol itself.

Evidence

The primary issue with MCP is not the protocol specification, but how agent harnesses load tools and context.

Question

Do measured failures attributed to MCP disappear when the same servers are used with progressive-discovery harnesses?

Source video
comparativeVerification needed

Progressive tool discovery produces a 60–95% difference in free context space versus eager tool loading.

Evidence

Analysis of context window consumption showing over 60-95% free space differences when using progressive tool search.

Question

What exact experimental setup produced the 60–95% range, and how does it scale with tool count?

Source video
causalVerification needed

Agents never load full CLIs into context; they explore them progressively, which is a core reason CLIs outperform naive MCP clients.

Evidence

Agents never load full CLIs into context; they load them progressively.

Question

Is the CLI advantage attributable to progressive discovery, shell pretraining, or both, and can they be isolated experimentally?

Source video
comparativeVerification needed

mcpc and native CLI performance are comparable on cost and time benchmarks.

Evidence

mcpc and CLI performance are very comparable in cost and time benchmarks.

Question

What benchmarks, task sets, and confidence intervals underlie the comparability claim?

Source video
opinionVerification needed

Raw MCP sometimes completes tasks faster but consumes more tokens than wrapper approaches.

Evidence

Raw MCP sometimes finishes tasks faster but consumes more tokens.

Question

How large is the latency advantage and the token penalty, and under what conditions?

Source video
causalVerification needed

Sub-agents isolate tasks but still incur token costs and retain sensitive data in context.

Evidence

Splitting context into sub-agents helps isolate tasks, but still incurs token costs and retains sensitive data in context.

Question

What proportion of the token cost remains after splitting, and what sensitive data actually persists across sub-agent boundaries?

Source video
factualVerification needed

mcpc is a lightweight, fully MCP-compatible CLI client that supports code mode via --json and agentic payments via x402.

Evidence

It supports code mode with --json flags and agentic payments via x402.

Question

Does mcpc's MCP coverage match the spec, and how does x402 payment flow integrate with agent tool calls?

Source video

Connections

5