Bedrock makes 3x more tool calls and API round-trips than direct API for identical tasks

Summary

Claude Code on Bedrock makes significantly more API calls and tool invocations than Claude Code on the direct Anthropic API for the same task, resulting in 3x slower completion times on complex tasks. The root cause appears to be fewer tools loaded on Bedrock (26 vs 45) and different model behavior causing more incremental, cautious execution.

Environment

• Claude Code v2.1.81
• Model: Sonnet 4.6
• Bedrock: EU cross-region inference profile (eu.anthropic.claude-sonnet-4-6)
• Anthropic: Direct subscription, Sonnet 4.6
• OS: macOS (Apple Silicon)

Reproduction

Task: Given an identical 1,820-line Python codebase with 3 bugs and duplicated code, asked Claude Code to:

1. Fix 3 bugs in utils.py
2. Refactor 15 duplicated dataclasses and 8 duplicated processor classes into base classes
3. Write and run tests

Same prompt, same codebase, same model (Sonnet 4.6), same machine, run back-to-back.

Results

| Metric | Bedrock | Anthropic Direct | Ratio |
|--------|---------|-----------------|-------|
| User-perceived time | 5m 36s | 1m 53s | 3.0x |
| API calls | 46 | 18 | 2.6x |
| Tool calls | 45 | 14 | 3.2x |
| Read calls | 23 | 6 | 3.8x |
| Edit calls | 8 | 3 | 2.7x |
| Bash calls | 4 | 1 | 4x |
| Grep calls | 6 | 1 | 6x |
| Max conversation messages | 210 | 84 | 2.5x |
| Final context tokens | 78,066 | 43,191 | 1.8x |
| Tools loaded | 26 | 45 | 0.58x |
| Avg TTFT per call | 2.43s | 1.85s | ~same |
| Avg generation speed per call | 5.06s | 5.26s | ~same |

Key Finding

Token generation speed is identical (5.06s vs 5.26s avg per call). The 3x total time difference comes entirely from:

1. 3.2x more tool calls — the model on Bedrock takes small incremental steps (23 reads, 6 greps) instead of bold moves (6 reads, 1 grep). Each tool call triggers a new API round-trip with ~2.4s TTFT overhead.

1. Fewer tools loaded — Bedrock loads 26 deferred tools, Anthropic direct loads 45. The 19 missing tools may be causing the model to fall back to more primitive, multi-step approaches.

1. Conversation bloat — 45 tool calls generate 210 messages (vs 84), causing context to grow to 78K tokens (vs 43K). Larger context = slower later calls.

Questions

1. Why does Bedrock load 26 tools vs 45? Which tools are excluded and why? Is this intentional?
2. Does the tool count affect model behavior? If the model has fewer tools available, does it become more cautious/incremental?
3. Can the tool set be made identical between Bedrock and direct API?

Debug Logs

Full debug logs available (--debug-file output) for both runs showing per-call timing, tool usage, and context growth. Happy to share if helpful.

Impact

We are deploying Claude Code via Bedrock to 150+ developers at an enterprise. This 3x performance gap on complex tasks significantly impacts developer productivity. Simple tasks (small projects, single-file edits) show no meaningful difference — the gap only appears on large codebases with complex multi-step work, which is the primary use case.