AI Engineer Code 2025

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

Jan Curn· Apify18:43

Loading slides…

Read the talk

MCP Doesn't Suck. Your Agent Does.

Selected presentation frame from MCP Doesn't Suck. Your Agent Does. — Jan Čurn, Apify at 224 secondsOpen full source frame
A slide argues that context overload is a harness problem, not an MCP problem.

Jan Čurn explains how eager tool loading wastes context, why shell interfaces avoid some of that waste, and how mcpc combines a local CLI with MCP’s remote protocol. The demo and early Connector Evals show both the appeal and the limits of that combination.

From a talk by Jan Curn

At a glance

Ideas worth remembering

  • Eagerly loading every tool description is a harness decision. Progressive discovery reduces the catalog the model must carry before doing useful work.

  • Sub-agents separate context windows, but do not eliminate token costs or make sensitive tool results safe to place in context.

  • mcpc combines a shell interface with MCP connections, persistent sessions, authentication, JSON composition and asynchronous tasks.

  • Early Connector Evals put mcpc near native CLI performance, while showing that completion time and token cost can favor different interfaces.

A hundred tools before the first question

An agent can spend a substantial part of its context window before doing any work. Jan Čurn, founder and CEO of Apify, opens with this concrete failure behind the MCP backlash: connect several servers, load every tool description immediately, and make the model carry the whole catalog through the conversation.

MCP standardizes access to tools and resources. Its adoption brought enough servers to need registries—and, in Čurn’s telling, enough registries to need registry registries. Enthusiasm then turned into complaints that MCP consumed too much context and should give way to command-line interfaces.

The example uses ten servers supplying roughly a hundred tools in total. An eager client registers all their descriptions in the model’s context. Each subsequent call adds more material, and its result comes back into the same conversation. The cost has two parts: an upfront catalog the task may barely use, followed by an accumulating history of outputs. Čurn’s suggestion that this could consume a third of the context is illustrative, rather than a measured result for a specified configuration.

The important implementation choice belongs to the agent harness: the software that decides what the model sees and how it executes tools. MCP supplies the interaction protocol; it does not prescribe this context-management strategy. Replacing the protocol therefore misses the decision that created the waste.

0:122:24

Separate context, discover tools, or execute code

Three approaches change different parts of that flow:

  • Sub-agents: Delegate work into a separate context window. This keeps the main conversation smaller, but the delegated tokens still cost money. A password returned into the sub-agent’s context also remains exposed to whatever can use that context; delegation alone does not solve sensitive-data handling.
  • Progressive tool discovery: Begin with a way to search for tools, then add descriptions when needed. Čurn points to Anthropic’s tool search tool and Cursor’s adoption of this approach. A task needing one or two tools no longer has to carry a hundred descriptions from the start.
  • Code Mode: Present tools as something the model can inspect and invoke through code. Search and code navigation help locate relevant definitions; execution can compose calls instead of making every operation a separate model-facing tool interaction.

Progressive discovery reduces what enters context before execution. Code Mode changes how execution itself happens. These can work together: find the small part of the interface relevant to the task, then write code that uses it. Large intermediate values need not become conversational material merely because one operation supplies input to another.

Selected presentation frame from MCP Doesn't Suck. Your Agent Does. — Jan Čurn, Apify at 320 secondsOpen full source frame
A slide presents progressive tool discovery as a way to limit which tool descriptions enter context.

Čurn’s rationale for Code Mode is model familiarity: models have learned from extensive code, while structured tool calling requires additional training. That is his explanation for why writing and invoking code can work better, rather than a universal performance guarantee. He also identifies a practical adoption problem: platform-specific implementations can be difficult to use, and clients may lag behind the protocol’s capabilities.

3:474:16

The shell already supplies discovery and composition

A CLI naturally encourages the behavior missing from the eager MCP client. An agent usually invokes a command when it needs it, consults help when it lacks the syntax, and uses familiar commands without first loading their entire manuals. Discovery happens as the task develops.

Execution also already happens as code. A machine or sandbox runs the shell command; pipes connect outputs to subsequent commands. Models have seen these patterns in training data, and command help and manual pages provide further material for learning them. The terminal’s compact output is useful here too: it concentrates operational information into a small amount of text.

The tradeoff appears when the command reaches a remote service. A CLI can hide its network protocol and authentication behavior behind its executable. Enterprise instrumentation and credential handling then depend on that particular implementation. Čurn favors MCP for standardized remote access and the CLI for the local interface an agent uses.

What sits between an agent’s familiar shell command and a remote MCP server? The diagram shows the proposed division of work. Bash supplies the model-facing entry point; a CLI client handles sessions and authorization while speaking MCP to the server. The protocol’s complexity moves into software that manages it, rather than disappearing.

Selected presentation frame from MCP Doesn't Suck. Your Agent Does. — Jan Čurn, Apify at 641 secondsOpen full source frame
A diagram places Bash between an AI agent and an MCP server.

A local shell interface over remote MCP access

AgentUses a familiar Bash tool to invoke commands.
mcpc CLI clientWraps MCP and keeps session state.
Local OS keychainStores credentials after browser authentication.
Remote MCP serverExposes tools and server information through MCP.
The agent uses Bash; the CLI client manages the MCP connection and authentication.
Read the diagram as text
  • Agent. Uses a familiar Bash tool to invoke commands.
  • mcpc CLI client. Wraps MCP and keeps session state.
  • Local OS keychain. Stores credentials after browser authentication.
  • Remote MCP server. Exposes tools and server information through MCP.
  • Agent → mcpc CLI client: Bash commands.
  • mcpc CLI client → Local OS keychain: Store authenticated credentials.
  • mcpc CLI client → Remote MCP server: Authenticated MCP connection.
7:167:46

mcpc makes protocol data usable in shell programs

mcpc is Apify’s universal CLI client for MCP, introduced here as a project that grew from a December hobby. Its design goal is broad protocol support—including tasks, resources and prompts—with a lightweight wrapper that contains no LLM. It can be installed through npm or Bun.

The key composition feature is --json. Commands can return structured data that tools such as jq can process and pass onward. A shell program can therefore connect several operations without asking the model to read and restate every intermediate result. Help text serves the other half of the interface: it is designed to let agents learn the commands without a separate skill package.

Selected presentation frame from MCP Doesn't Suck. Your Agent Does. — Jan Čurn, Apify at 705 secondsOpen full source frame
A slide lists mcpc design goals: MCP support, a lightweight wrapper, and ease of use.
10:4611:16

Connect once, then search the available tools

The demonstration begins with a local File System server, labeled FS, using stdio to communicate with a process on the computer. Connecting reveals the server name, protocol, capabilities, tools and available commands. The same information can be requested as JSON, making the interface inspectable by both a person and a program.

The remote Apify connection adds authentication. Login opens a browser, the user selects an account, and mcpc stores credentials in the local OS keychain. After connecting, the client displays server information, including the server’s instructions explaining what it does. It can then list tools and commands.

The session list now contains three MCP sessions. mcpc persists them so the user can return later, and different agents—such as Claude Code and Codex—can use the same established setup. Connection state lives in the client rather than requiring each agent to recreate the configuration.

Progressive discovery becomes concrete with mcpc’s grep command. Searching for find returns three matching tools from FS and four from Apify. The observable change is from a set of connected servers to a short, relevant selection of tools. Searching the available descriptions narrows what the agent needs to inspect; connecting to a server does not require presenting its whole tool catalog to the model upfront.

12:4113:12

Start remote work without holding the foreground

Next, an Apify web-search tool illustrates asynchronous execution. Adding --task starts work on the server while leaving the local client free to do something else. The client can check progress and retrieve results later, or detach while the task continues. Čurn detaches during the demo; the sequence demonstrates background execution rather than a completed search result.

Asynchronous tasks and JSON composition address different costs. A task frees the foreground while remote work runs. A shell pipeline keeps intermediate processing outside the model’s conversation. Together, they let ordinary programs coordinate MCP operations while reserving context for information the agent actually needs to reason about.

The closing feature tour also mentions x402 support, local wallet management and proxy commands for sandboxing. These broaden mcpc’s intended role, but the recording does not develop their payment or isolation mechanisms.

14:5515:25

Compare the connector while keeping the agent fixed

Connector Evals changes the benchmark question. Instead of comparing agents, it compares the interfaces through which an agent works: native CLI, raw MCP and mcpc. The presented tests use Claude Code. This focuses attention on whether the connector itself changes completion time and token cost.

The charts place task completion time on the horizontal axis and token cost on the vertical axis. In the first comparison, mcpc and the native CLI perform similarly; raw MCP finishes faster but consumes more tokens. Other presented comparisons again put mcpc near the CLI, with raw MCP performing worse. These are early results without numerical values or enough evaluation detail in the recording to establish a general ranking. They also preserve a useful tradeoff: the lowest token cost need not coincide with the fastest completion.

The ending’s proposal follows directly from the implementation: use MCP’s standardized connection to remote tools, expose it through a CLI that agents can discover and compose, and measure the resulting connector behavior. “MCP plus CLI” is the combination Čurn wants tested and improved. Choosing how an agent discovers tools, carries data and runs work matters as much as choosing the protocol.

16:4017:10

Resources

Transcript download
Full transcript

Loading transcript…