The Shell Is the Most Underrated Interface in AI

There’s a quiet assumption running through most of the AI agent discourse: that agents need tools. Lots of them. Custom-built, schema-defined, carefully orchestrated tools.

MCP is being positioned as the standard for agent-tool integration. Web agents are learning to navigate GUIs. Agent frameworks are competing on how many integrations they ship. The entire ecosystem is converging on the idea that the way to make agents more capable is to give them more stuff.

I think this is backwards.

A new paper from ServiceNow, “Terminal Agents Suffice for Enterprise Automation,” makes a compelling case that a coding agent with nothing but a terminal and a filesystem can match or outperform these complex architectures across real-world enterprise tasks. No tool abstractions. No browser automation. No MCP. Just a foundation model and a command line.

This shouldn’t be surprising. But somehow it is.

The training data already solved this

Every major LLM has been trained on massive amounts of Linux shell content. Man pages, Stack Overflow answers, GitHub repos, sysadmin guides, READMEs, tutorials. The shell is probably the single most well-represented human-computer interface in LLM training corpora.

This matters more than people realize. When you give a model a shell, you’re not asking it to learn something new. You’re meeting it where it already has deep, rich competence. Every command, every pattern, every idiom is already in the weights.

Now compare this to a custom tool. Every tool you add is an abstraction the model has to learn to use correctly. The schema, the calling convention, the response format, the edge cases. None of this is in the training data. The model has to figure it out from a description you cram into the context window.

Which brings us to the real problem.

Intelligence is finite. Don’t waste it on tools.

The intelligence of an agent is dependent on its training. Everything the agent has to learn that isn’t already in the training set takes away from the intelligence it can deploy to actually solve the problem.

This is the hidden cost of tool-heavy architectures. When you fill an agent’s working memory with dozens of tool definitions, schemas, and usage instructions, you’ve fundamentally handicapped it. The agent is now spending cognitive capacity on figuring out which tool to call and how to call it, instead of spending that capacity on the actual task.

Think of it like driving while making a phone call. You can technically do both, but you’re unable to bring your full intelligence to bear on driving. The result, eventually, is an accident.

The shell sidesteps this entirely. The model already knows how to use it. You don’t need to pollute the context with tool definitions to unlock this capability. It’s already there. The context stays minimal. The agent stays sharp and unencumbered.

Every API can be called with curl. Every file can be read with cat. Every transformation can be done with standard Unix utilities or a quick script. You don’t need a custom Jira tool or a Salesforce tool or an AWS tool. You need the API docs and a shell.

MCP is solving a problem that the shell already solved

MCP makes sense if your agent can’t write code. If all it can do is pick from a menu of predefined tools, then yes, you need a protocol for discovering and calling those tools.

But if your agent can write and execute code in a shell, MCP is a layer of indirection that adds complexity without adding capability. The shell already gives you access to everything MCP would, and more. The ServiceNow paper backs this up. Their terminal agents matched or outperformed MCP-augmented architectures.

Web interfaces were built for humans. Making agents navigate them is like holding your ear the other way around. It works, technically, but it’s fragile and inefficient.

Agents will very soon be the biggest consumers of all web-based software. When that happens, every piece of software will either have an API or be left behind. The shell-first approach fits naturally into this future. APIs are how software talks to software. The shell is how you call APIs. No awkward middle layer required.

We built nonbios around this philosophy. It’s a terminal agent. Everything runs through a shell. Zero tools. No MCP. The early results have validated the approach, and now the research is catching up.

But this isn’t really about nonbios. It’s about a broader pattern in engineering where the simple, boring, already-proven solution beats the complex, novel, heavily-marketed one. The terminal has been the backbone of computing for 50 years. It didn’t need reinventing. It just needed a smarter operator.

The shell was always the right interface. We just needed models smart enough to use it.

Paper: “Terminal Agents Suffice for Enterprise Automation” by Patrice Bechard, Sai Rajeswar, and the ServiceNow AI team.