# Tool-Interface Choice Shapes Agent Architecture More Than Model Choice How an AI agent reaches the outside world — the **Model Context Protocol (MCP)** versus a plain **command-line interface (CLI)** — is an architectural decision with consequences the model choice doesn't touch. Grafana's "Context Window" team, comparing their MCP server against `gcx` (their agent-facing CLI), found the two reach similar outcomes through opposite trade-offs. MCP front-loads **tool discoverability**: it ships structured, authenticated tool definitions the agent can enumerate. A CLI front-loads **token efficiency**: the agent discovers commands progressively (`--help`, subcommands) and pays tokens only for what it actually inspects, but it has to know the commands exist. The deciding factors are environmental, not about which is "better." A remote surface with no shell (claude.ai, a hosted chat) *cannot* run a CLI — it must use a remote MCP server; that's not a preference, it's the only option. A local IDE or `claude code` session can do either, and the choice collapses to taste and to whether you're willing to run arbitrary binaries on the machine. So the interface is chosen by the **deployment environment and the trust model**, and that choice then constrains token budget, tool sprawl, and reliability downstream — all without changing the model at all. <!-- atomicity: 1 idea ✓ --> ## Why This Matters For **agent design**, this says architecture is upstream of model selection. Teams reflexively ask "which model?" when the higher-leverage question is "how does it reach tools, and what does that cost per call?" It is the interface-level companion to [[3. Resources/Permanent Notes/Bounded Action Spaces Not Better Models Make Agents Safe to Run]]: there, *what the agent may do* is the safety lever above the model; here, *how the agent reaches tools* is the architecture lever above the model. For **tokenomics**, the CLI-vs-MCP trade is a direct cost lever. Tool sprawl and always-loaded MCP schemas burn context-window tokens whether or not they're used; progressive CLI discovery trades that for round-trips. This is the same family of cost-at-the-request-level argument as [[3. Resources/Permanent Notes/Vague Prompts Are Expensive Specificity Cuts AI Error and Cost Together]] — the structure of the interaction, not just the model, sets the bill. ## Counterpoints to Hold - **The gap is closing.** The team noted the token-efficiency difference is "closing in on each other" as MCP implementations get leaner — so today's trade-off may not persist. - **Outcome parity can hide reliability differences.** "Similar outcomes" in a benchmark (o11y-bench) doesn't mean equivalent failure modes under production load; discoverability vs. efficiency may diverge at scale. ## Links - [[3. Resources/Literature Notes/Lit · MCP vs CLI tradeoffs for AI agents]] — evidence-for; the benchmark shows interface choice trading CLI token efficiency against MCP tool discoverability while model capability stays constant. - [[3. Resources/Permanent Notes/Zet · Multi-model routing beats single-model for creative work]] — extends: interface architecture determines how subtasks are exposed, while routing architecture assigns each one to the model best suited to it - [[3. Resources/Permanent Notes/Zet · CLIs trade tool discoverability for token efficiency]] — evidence-for: CLI help discovers interface detail on demand, while MCP schemas buy immediate enumeration by spending context before use - [[3. Resources/Permanent Notes/Bounded Action Spaces Not Better Models Make Agents Safe to Run]] — the safety lever above the model; this is the architecture lever above the model - [[3. Resources/Permanent Notes/Vague Prompts Are Expensive Specificity Cuts AI Error and Cost Together]] — the request-level cost twin; interface structure is another token lever - [[3. Resources/Permanent Notes/Agent-First vs Gateway-First Are Two Architectures for Self-Hosted AI Agents]] — the reach/connection-surface decision this interface choice sits inside - [[3. Resources/Permanent Notes/The Harness Now Outpaces the Model as the Source of Agent Capability Gains]] — generalizes this note's thesis: interface is one harness lever above the model; that note makes the broader claim that the whole loop now outranks the model for capability - [[3. Resources/Permanent Notes/Claude Desktop - Clean Config Reference]] — evidence-for: duplicated always-loaded MCP schemas caused timeouts until the interface configuration was reduced to one source per service - [[3. Resources/Permanent Notes/Core Abilities Must Be Consumer-Neutral Primitives Not One Interface's Mirror]] — extends: interface choice stays open only when the underlying capability is expressed as a consumer-neutral primitive. - [[3. Resources/Permanent Notes/Route Judgment to the Expensive Model and Bulk Execution to the Cheap One]] — extends: interface architecture determines how work is exposed, while routing architecture determines which model tier performs each part - [[3. Resources/Permanent Notes/The Design File as a Programmable Bidirectional Surface for Agents]] — applies-in: an open design-file data model is the interface choice that makes deep agent reading and writing possible. ## Open Questions - Is there a hybrid (CLI behind an MCP-discoverable manifest) that gets discoverability *and* token efficiency? - Does the right interface change as an agent matures from exploration to routine operation? ## Source - [[3. Resources/Readwise/Articles/CLI and MCP Basics for AI Agents|CLI and MCP Basics for AI Agents — The Context Window #4]] — MCP = structured/authenticated discoverability; CLI = progressive discovery + token efficiency; environment (remote vs local shell) decides; gap closing; o11y-bench parity - See also: [[AI Cost & Tokenomics MOC]], [[AI Agent Safety MOC]]