Why AI Coding Agents Need Better Terminals, Not Fewer Terminals

The Terminal Isn’t Dead—It’s Becoming Mission Control

The AI coding industry has convinced itself it’s heading toward a terminal-free future. Autonomous agents working in the cloud, handling PRs end-to-end, no human babysitting required. The command line, in this vision, is a relic—something agents graduate from once they’re sophisticated enough.

Amp’s new Neo CLI suggests the opposite thesis: the terminal matters more in an agentic future, not less. The difference is what the terminal becomes. Not a place where agents live, but a control surface where developers coordinate systems running everywhere else. Amp rebuilt its CLI from scratch specifically to enable remote control, plugin extensibility, and management of long-running agent workflows that exist outside the local session. That’s not a retreat to old workflows. It’s recognition that as agents become more autonomous, developers need better interfaces for oversight, not fewer touchpoints.

The broader pattern here matters more than one company’s product strategy. Every major player in AI coding is wrestling with the same question: where does the human fit once agents can complete tasks end-to-end? The answer emerging across the industry isn’t “nowhere”—it’s “differently.” And the terminal, counterintuitively, is where that shift becomes most visible.

Remote Control Reveals the Real Architecture Shift

Neo’s headline feature is remote controllability. Start a coding session locally, manage it from the browser. Stream terminal output to the web interface. Queue new prompts, interrupt tasks, or kill the agent entirely without touching the command line. That’s useful, but the architectural change underneath is what matters: Amp moved the agent loop itself into the cloud.

Quinn Slack, Amp’s CEO, noted the system now uses 95% less data between client and server. That reduction comes from not running the agent inside the terminal session. The terminal becomes a thin client—displaying output, accepting input, but not hosting the actual execution logic. The agent runs remotely; the CLI is just where you watch and steer.

This mirrors what GitHub Copilot CLI and Claude Code have also introduced recently: the ability to monitor and control coding sessions from outside the terminal. The pattern is consistent: agents are decoupling from local environments. But rather than abandoning the terminal interface entirely, companies are transforming it into a remote control for processes that live elsewhere.

Amp also added a plugin system, “compaction-first” architecture for managing long conversational histories, exposed reasoning during execution, and token/cost tracking directly in the interface. These aren’t features you build for a dying interface. They’re features you build for a coordination layer that needs to scale with increasingly complex agent workflows.

The technical details matter because they reveal intent. Amp didn’t just add remote access to an existing CLI. It rebuilt the entire system around the assumption that the agent and the terminal are separate entities that need a better communication protocol.

The Industry Is Splitting on Where Agents Should Live

Amp isn’t alone in rethinking agent architecture, but companies are reaching different conclusions about what comes next.

Roo Code went furthest in the opposite direction. In April 2025, the company shut down its VS Code extension entirely and pivoted to Roomote—a cloud-based autonomous agent designed to operate across Slack, GitHub, and Linear without requiring an IDE at all. Matt Rubens, Roo Code’s CEO, argued that once agents can create good pull requests from a single prompt, “you let go of the IDE and focus on driving things end-to-end.”

That philosophy—agents as fully autonomous workers, not assistants—represents the other pole in this debate. If the system can complete tasks without supervision, why maintain interfaces designed for real-time human interaction? Just give it instructions and review the output later.

Meanwhile, Atlassian introduced a CLI this week explicitly not for developers, but for their agents. The Teamwork Graph CLI lets AI coding systems query and act across Jira, Confluence, Bitbucket, and other Atlassian tools. Install it once; agents use it from then on. Atlassian calls it “the skill layer for AI coding agents,” and it’s telling that an incumbent enterprise vendor is building tooling that’s agent-readable by default rather than retrofitting existing interfaces.

These approaches share a common assumption: momentum is shifting away from agents living inside a single editor or tightly scoped local session. But they differ sharply on what replaces that model. Fully autonomous cloud workers? Hybrid systems with better remote oversight? Multi-tool coordination layers?

Amp’s bet is that even as agents gain autonomy, developers will want moments where the agent is “right next to you”—and those moments happen in the terminal. That’s less about nostalgia for CLIs and more about recognizing that oversight requires interfaces, and terminals are already optimized for real-time interaction with long-running processes.

The Counterargument: Terminals Are Fundamentally Human Interfaces

The strongest argument against Amp’s approach is that terminals are designed for humans, and optimizing for human interaction limits how autonomous agents can become.

If you keep developers in the loop via a CLI, you’re still building around synchronous interaction patterns. The human starts a session, monitors output, intervenes when needed. That’s fine for assisted coding, but it’s a constraint on true autonomy. Roo Code’s pivot away from IDEs makes sense if you believe the next phase of AI coding involves agents working in parallel across multiple environments, creating PRs, running tests, and verifying fixes without requiring a human to watch a terminal stream.

There’s also an efficiency argument. Moving the agent loop to the cloud while maintaining a terminal interface means you’re still rendering output for human consumption in real-time. That’s overhead. If the agent is running remotely and completing tasks autonomously, why not just surface summaries and outcomes asynchronously rather than streaming every intermediate step?

Amp’s answer seems to be that developers don’t trust black-box systems yet. Exposing reasoning, streaming output, and allowing real-time intervention are trust-building features, not technical necessities. But that raises the question: how long do those training wheels stay on?

The counter-counterargument is that this isn’t about trust—it’s about control surface design. Even when agents are highly autonomous, someone needs to prioritize tasks, handle exceptions, and make judgment calls about what “done” means. Terminals are good at that kind of real-time coordination because they’re optimized for rapid command input and continuous feedback. Web dashboards and async summaries work for monitoring, but they’re slower for intervention.

Amp is betting that the terminal evolves into mission control, not that it remains the cockpit. That’s a meaningful distinction. Mission control doesn’t fly the spacecraft, but it’s still where humans make decisions when things go off-script.

Where This Leads: CLIs Become Agent APIs

Here’s the specific, falsifiable prediction: by mid-2027, the leading AI coding platforms will have CLIs that function primarily as APIs for agent coordination rather than direct human input tools. You’ll still use the terminal, but mostly to start workflows, check status, and intervene in edge cases. The bulk of interaction will happen through natural language instructions routed to agents that execute across multiple environments.

Second prediction: we’ll see a new category of tooling emerge around “agent control surfaces”—interfaces specifically designed for monitoring and steering multiple autonomous agents running in parallel. These won’t be traditional dashboards or CLIs. They’ll be hybrid interfaces that combine real-time streaming (for active monitoring), async summaries (for status checks), and command-line-style input (for rapid intervention). Amp’s Neo is an early version of this.

Third: enterprises will standardize on agent-readable infrastructure faster than consumer tools. Atlassian’s Teamwork Graph CLI is a signal. Large organizations with complex toolchains need their agents to work across Jira, GitHub, Slack, and internal systems. The coordination layer becomes the product, not the coding assistant itself. Expect more incumbents to release agent-first APIs and CLIs over the next 18 months.

The longer-term implication is that “AI coding” becomes less about where the code gets written and more about orchestration. The terminal doesn’t die—it becomes one interface among many for managing distributed agent workflows. Developers become more like conductors than instrumentalists, coordinating systems rather than typing every line themselves.

Amp’s rebuild isn’t a defense of the terminal. It’s recognition that as agents move beyond the command line, developers need better ways to reach them when they’re out there. The terminal is just the most familiar place to put that control panel.