Why Claude Code With MCP Tools Requires Higher Effort Levels (And How to Fix It)

Mar 13, 2026

Problem

I noticed something strange when using Claude Code with MCP (Model Context Protocol) tools connected. At the default medium effort level, Claude would sometimes skip reading tool results carefully. It would make assumptions about what a tool returned instead of actually parsing the output. This led to errors and incomplete responses.

Here’s what I experienced:

Claude would claim a tool returned data that it didn’t
It would ignore error messages from MCP tools
Sometimes it would use the wrong tool parameters because it “assumed” the previous tool’s structure
Complex nested JSON from MCP tools got partially processed

I checked my configuration, verified my MCP servers were running correctly, and couldn’t figure out why the results were inconsistent.

What happened?

I found discussions in the community about this exact issue. The key insight was simple: effort level matters way more when you have MCP tools connected.

One user explained:

“At medium effort Claude sometimes skips reading tool results carefully or makes assumptions about what a tool returned. Bumping to high fixed a bunch of those issues for me, especially with tools that return complex structured data.”

Another user added:

“MCP’s use up a ton of tokens/context window. I stick to skills/expertise yaml etc.”

This made me realize: MCP tools add cognitive load to Claude. Each tool call produces results that need to be parsed, validated, and integrated into the reasoning process.

How to solve it?

The solution is straightforward: increase effort level to high when using MCP tools.

Here’s how I configured it:

{
  "effort": "high"
}

Or if you want to set it per-project:

{
  "effort": "high"
}

After making this change, I tested the same MCP workflows that were failing before:

Test 1: Complex nested JSON from a tool

Before (medium effort):

[Tool: fetch_user_data]
Claude: "The user data has been retrieved."
[Missing: actual data processing]

After (high effort):

[Tool: fetch_user_data]
Claude: "Retrieved user data with nested structure:
- id: 12345
- profile.name: "John Doe"
- profile.preferences.theme: "dark"
- profile.preferences.notifications: true
Processing each field..."

Test 2: Error handling

Before (medium effort):

[Tool: database_query returned error]
Claude: "The query was executed."
[Ignored the error message]

After (high effort):

[Tool: database_query returned error]
Claude: "Error detected: Connection timeout after 30s.
Possible causes:
1. Database server not responding
2. Network connectivity issue
3. Query timeout threshold too low
Would you like me to retry with increased timeout?"

The difference is clear: with high effort, Claude takes the time to actually read and process tool outputs.

The reason

Why does effort level matter so much for MCP tools? I found four key reasons:

1. Complex Structured Data Processing

MCP tools often return nested JSON objects, arrays, and complex data structures:

{
  "users": [
    {
      "id": 1,
      "profile": {
        "name": "John",
        "settings": {
          "theme": "dark",
          "notifications": {
            "email": true,
            "push": false
          }
        }
      },
      "permissions": ["read", "write", "admin"]
    }
  ],
  "meta": {
    "total": 100,
    "page": 1,
    "hasMore": true
  }
}

At medium effort, Claude might only process the top-level structure. At high effort, it parses nested fields carefully.

2. Tool Result Verification

Each MCP tool call produces results that Claude must:

Read completely
Validate against expected schema
Integrate into ongoing reasoning

This requires sustained attention. Medium effort treats this as skimmable; high effort treats it as critical.

3. Context Window Consumption

MCP tools consume significant tokens. The community feedback confirmed this:

“MCP’s use up a ton of tokens/context window.”

With limited reasoning budget at medium effort, Claude optimizes by skipping “careful reading” steps. High effort allocates more capacity to parsing.

4. Multi-Step Reasoning Chains

MCP workflows often require multiple tool calls in sequence:

Tool A returns data -> Tool B processes it -> Tool C stores result

If any step is misread, the chain breaks. High effort ensures each step is processed correctly.

What goes wrong at medium effort

I tracked the specific issues I encountered:

Issue	Symptom	Root Cause
Skipped parsing	Missing data in response	Claude assumes structure
Assumed results	Wrong tool used next	Didn’t read actual output
Error blindness	Ignoring tool errors	Rushed result processing
Context loss	Forgetting earlier results	Token pressure
Type confusion	Wrong parameter types	Assumption over validation

The pattern is consistent: medium effort prioritizes speed over accuracy. For MCP tools, this tradeoff fails.

When to use which effort level

Based on my testing:

Effort Level	When to Use	MCP Tools
Low	Simple file edits, quick questions	No MCP tools
Medium	Standard coding, file operations	Minimal MCP usage
High	Complex workflows, multiple tools	Heavy MCP usage
Max	Critical operations, debugging	MCP with critical data

For most MCP-heavy workflows, high effort is the safe default.

Alternative: Limit MCP tool usage

The community also suggested another approach:

“I stick to skills/expertise yaml etc.”

This means: if you don’t need MCP tools, don’t use them. They add overhead. For simple tasks, native tools and skills work better:

# Instead of MCP file server
skills:
  - file-operations  # Built-in skill

# Instead of MCP web fetcher
skills:
  - web-fetch  # Built-in skill

# Keep MCP for specialized needs
mcpServers:
  - database-connector  # No native alternative
  - custom-api-client   # Project-specific

This hybrid approach: native tools for common operations, MCP for specialized needs.

Summary

In this post, I explained why MCP tools require higher effort settings in Claude Code. The key points are:

MCP tools return complex structured data that needs careful parsing
Medium effort causes Claude to skip reading or assume results
High effort allocates reasoning capacity for thorough tool output processing
Consider limiting MCP usage to specialized needs

The fix is simple: set effort: high in your settings when using MCP tools, or keep MCP usage minimal and rely on native skills for common operations.

Final Words + More Resources

My intention with this article was to help others share my knowledge and experience. If you want to contact me, you can contact by email: Email me

Here are also the most important links from this article along with some further resources that will help you in this scope:

👨‍💻 Claude Code Documentation
👨‍💻 Model Context Protocol Specification

Oh, and if you found these resources useful, don’t forget to support me by starring the repo on GitHub!