# AI Agents Don’t Need Your Developer Tools > Vercel built sixteen specialized tools for their AI agent. ESSAY · MAR 2026 · 8 min read · by Noah Mitchem Vercel built [**sixteen specialized tools**](https://vercel.com/blog/we-removed-80-percent-of-our-agents-tools) for their AI agent. Then they deleted 80% of them and replaced everything with one capability: execute bash commands. Success rate went from 80% to 100%. Speed improved 3.5x. Token usage dropped 37%. > “Maybe the best agent architecture is almost no architecture at all.” — Andrew Qu, Vercel’s Chief of Software Vercel isn’t an outlier. They’re a case study in a pattern the developer tools industry is desperately trying to ignore: AI agents don’t want the tools we’re building for them. They want bash, a file system, and git. The developer tools industry is literally spending billions building in the opposite direction. ## The Gold Rush Nobody Questioned AI-native developer tools are the hottest category in tech. Eight companies in the space (Claude Code, Cursor, Replit, Lovable, Devin, Base44, Emergent**,** and Bolt) have already crossed a [combined **$5 billion** in annual recurring revenue](https://x.com/JayminSOfficial/status/2029842039744122949). Investors see transformation. > “AI now creates millions of software builders,” angel investor Jaymin Shah wrote in his post. “When the number of builders expands, the number of products grows exponentially.” He’s right about the growth. But nobody in this gold rush stopped to ask a basic question: what do the AI agents building all this software actually prefer to use? The market says the answer is AI-native platforms, specialized frameworks, and new protocols. The data says it’s bash. Google and Accel recently reviewed over 4,000 startup pitches. Roughly [**70%** were rejected](https://techcrunch.com/2026/03/15/google-and-accel-cut-through-wrappers-in-4000-ai-startup-pitches-to-pick-five-tied-to-india/) as “wrappers”, thin UI layers on existing models with zero underlying innovation. Of the 14,000 AI startups launched in 2024, [over **5,600** ](https://simpleclosure.com/blog/posts/state-of-startup-shutdowns-2025/)have already shut down. Forty percent failure in under 24 months. And Gartner predicts [30% of agentic AI projects will fail](https://www.gartner.com/en/newsroom/press-releases/2024-07-29-gartner-predicts-30-percent-of-generative-ai-projects-will-be-abandoned-after-proof-of-concept-by-end-of-2025). Not from lack of tooling, but from poor data foundations. The industry is solving the wrong problem. It’s building tools nobody asked for. ## Agents Vote With Their Tokens When you look at what AI agents actually choose to use, measured by adoption, reliability, and cost, the picture is pretty clear. The most popular AI coding tool in the world is Claude Code. It earned the #1 spot in [the Pragmatic Engineer’s 2026 survey](https://newsletter.pragmaticengineer.com/p/ai-tooling-2026), with 46% of developers calling it “most loved.” [Four percent of all public GitHub commits](https://newsletter.semianalysis.com/p/claude-code-is-the-inflection-point) now come from it, projected to exceed 20% by year’s end. And its architecture is, to a first approximation, a terminal. Its tools are bash, grep, file read, file write, and git. That’s it. An open-source project called [learn-claude-code](https://github.com/shareAI-lab/learn-claude-code) demonstrated that you can reproduce its core agent loop in roughly 30 lines of Python. Thariq, an engineer on the Claude Code team at Anthropic, summarized the philosophy in two threads: “[Your agent should use a file system](https://x.com/trq212/status/1970243253061783669?s=20)” and “[Bash is all you need.](https://x.com/trq212/status/2035372727595343985?s=20)” GitHub reached a similar conclusion from the opposite direction. They [reduced Copilot’s tool count from over 40 to 13](https://github.blog/ai-and-ml/github-copilot/how-were-making-github-copilot-smarter-with-fewer-tools/) core tools. Performance improved. Pre-expansion accuracy jumped from 19% to 72%. SWE-bench scores went up 2–5 percentage points. Fewer tools, better results. Then there’s MCP, the Model Context Protocol, an open standard created by Anthropic for connecting AI agents to external tools and data sources. [Independent benchmarks](https://www.scalekit.com/blog/mcp-vs-cli-use) show MCP server integrations are 10–32x more expensive than equivalent CLI commands and achieve only 72% reliability compared to CLI’s 100%. In one test, an MCP agent consumed 44,000 tokens for a query that a CLI agent handled in 1,365. Perplexity’s CTO Denis Yarats [publicly announced](https://x.com/morganlinton/status/2031795683897077965?s=20) in March 2026 that the company is moving away from MCP. The most telling signal comes from Anthropic itself. Their recently introduced Skills feature [converts what would have been MCP tool calls into filesystem-based patterns](https://danielmiessler.com/blog/anthropic-downplays-mcps), saving 98.7% on token usage, from 150,000 tokens down to 2,000. The company that created MCP is routing around its own protocol. Pieter Levels, the indie developer with dozens of shipped products, [put it bluntly](https://x.com/levelsio/status/2031943074151104634?s=20): > “Thank god MCP is dead. It’s all dumb abstractions that AI doesn’t need because AIs are as smart as humans so they can just use what was already there — which is APIs.” ## The Ergonomics Mismatch If you want to understand why agents keep reaching for bash over purpose-built tools, you have to understand what developer tools actually are. We built syntax highlighting because humans can’t parse raw text at speed. We built autocomplete because we type slowly and forget API signatures. The whole industry is, at root, a set of workarounds for the limitations of the human brain. AI agents don’t have those limitations. They parse tokens, not pixels. They hold entire codebases in context. They can generate, resolve, and maintain dependency trees without ever seeing a visual interface. Every “feature” we built for human ergonomics becomes friction for a non-human user that processes text natively. Alain Di Chiappari articulated this in [an essay](https://blog.alaindichiappari.dev/p/software-engineering-is-back): > “Bash was born in 1989. The most mediocre model running at this time knows bash better than any person in the world. Bash is the universal adapter. It is not a coincidence that coding agents are shifting from complex and expensive MCP configurations to a simple agent loop with bash as a way to interact, literally, with the world. The oldest tool turned out to be the most future proof.” A January 2026 paper on arXiv titled “[From Everything-is-a-File to Files-Are-All-You-Need](https://arxiv.org/abs/2601.11672)” traced this phenomenon academically, arguing that Unix’s uniform read/write interface, designed in the 1970s, maps directly onto how AI agents want to interact with the world. The agents face an “interface proliferation problem” when forced to juggle REST APIs, SQL databases, vector stores, and cloud consoles. A file system collapses all of that into something composable. At Dust, engineers [noticed something remarkable](https://dust.tt/blog/how-we-taught-ai-agents-to-navigate-company-data-like-a-filesystem): their AI agents were spontaneously inventing filesystem-like syntax for searching company content, using patterns like `file:front/src/some-file.tsx`, instead of the semantic search interface they’d been given. The agents weren’t told to use filesystem patterns. They preferred them. We built a $50 billion industry around compensating for the limitations of the human brain. Then we welcomed a user that doesn’t have a human brain and tried to sell it the same products. ## The Framework Funeral Agent frameworks (LangChain, CrewAI, AutoGen, and many others) were supposed to make building AI agents easier. They offered abstractions for tool calling, memory management, chain-of-thought reasoning, and multi-agent orchestration. A reasonable bet. Here’s how that bet played out. Microsoft [placed AutoGen into maintenance mode](https://venturebeat.com/ai/microsoft-retires-autogen-and-debuts-agent-framework-to-unify-and-govern) in October 2025. BabyAGI was [archived](https://github.com/yoheinakajima/babyagi) in September 2024 after receiving 20K+ stars. Octomind, a company that used LangChain in production for over a year, [ripped it out entirely](https://www.octomind.dev/blog/why-we-no-longer-use-langchain-for-building-our-ai-agents) and published a detailed explanation: “When we were spending as much time understanding and debugging LangChain as building features, it wasn’t a good sign.” Meanwhile, HuggingFace’s [SmolAgents](https://huggingface.co/blog/smolagents) fits its core agent logic in roughly 1,000 lines of Python. It reduces LLM calls by 30% compared to traditional agent frameworks. The model writes standard Python rather than navigating complex JSON schemas or framework-specific abstractions. Anthropic’s own guidance, published in their “[Building Effective Agents](https://www.anthropic.com/research/building-effective-agents) blog post, is perhaps the most damning evidence: “The most successful implementations weren’t using complex frameworks or specialized libraries. Instead, they were building with simple, composable patterns.” The company that builds Claude, the model powering the most popular AI coding agent, is telling developers not to use frameworks. Frameworks were always a compromise: trading flexibility for velocity because humans couldn’t hold enough complexity in their heads. Agents can hold the complexity. The trade-off no longer makes sense. ## What Agents Actually Need So if agents don’t need our tools and they don’t need our frameworks, what do they actually need? The honest answer is mostly boring: well-documented APIs with stable contracts, reliable file systems, clean version control semantics, structured I/O, and sandboxing. The kind of infrastructure that has existed in some form for decades. But there’s a catch. The old infrastructure works at human scale. Agents operate at a different scale entirely, and that’s where genuine gaps emerge. Not in the application layer, but in the infrastructure layer underneath it. Agents shouldn’t need to clone an entire repository to read three files. They need virtual filesystems that provide lazy, partial access to remote code. Agents working in parallel shouldn’t collide in merge conflict cascades. They need version control with native concurrent write semantics and mutable change primitives. When an agent introduces a subtle bug, you need to query what model, prompt, and context produced the change. Git’s commit metadata doesn’t carry that provenance. And as organizations spin up hundreds of agents per repository, they need permission scoping at the forge level: repo-scoped API keys, path-restricted access, sandbox boundaries enforced by the platform rather than by the agent’s good behavior. Aaron Levie, Box’s CEO, [said it directly on CNBC](https://www.cnbc.com/video/2026/03/04/techcheck-box-ceo-ai-agents-will-be-the-biggest-users-of-software-in-the-future.html) in March 2026: > “AI agents will be the biggest users of software in the future. And agents actually need a file system to be able to do their work.” A handful of companies have started building at this layer. Instead of another dashboard or another MCP integration, they’re working at the protocol level: VCS primitives, virtual filesystems, change semantics. The boring infrastructure that agents actually touch. The existing tools aren’t dying for humans. Developers still need syntax highlighting and dashboards and visual debuggers, and companies like Cursor are building [$2 billion businesses](https://techcrunch.com/2026/03/02/cursor-has-reportedly-surpassed-2b-in-annualized-revenue/) serving that need. Enterprise environments still need the governance that protocols like MCP provide: OAuth, audit trails, per-user permissions. These are real requirements for human developers working with AI. But the growth market isn’t human developers anymore. The next hundred million “developers” won’t be human. And the infrastructure that earns their usage will look nothing like the tools we built for ourselves. ## The Right Question The developer tools industry keeps asking how to make its products AI-native. That question already contains the wrong assumption. Agents don’t need tools. They need primitives. Interfaces. Protocols. Plumbing. Now, there’s a version of this argument that falls apart. Bash works great when an agent is operating on a local codebase with a filesystem it can see. It works less well when the agent needs to authenticate against a cloud provider, orchestrate a multi-step deployment, or interact with a system that has no CLI at all. The “just use bash” thesis has real limits, and anyone building infrastructure for agents will hit them quickly. But the direction is clear. The most future-proof developer tool was built in 1989. The most future-proof developer infrastructure hasn’t been built yet, and when it arrives, it’ll look less like a product and more like plumbing. --- Source: https://noahmitchem.com/notes/ai-agents-don-t-need-your-developer-tools — this is the Markdown representation of that page, served from the same URL to clients that send `Accept: text/markdown`. Site index for agents: https://noahmitchem.com/llms.txt · Full site text: https://noahmitchem.com/llms-full.txt · Contact: noah@noahmitchem.com