The more things change, the more they can remain the same.
The Integrated Development Environment — the IDE — has been a cornerstone of software engineering for decades. It is where code gets written, debugged, and shipped. But as AI agents increasingly take over the act of writing code itself, a provocative question has emerged: do humans now need a new kind of IDE, not to write code, but to manage the agents doing it for them?
That is precisely what Andrej Karpathy, one of the most influential figures in modern AI, is now suggesting.
From Tmux Grids To Something More
The conversation was sparked by a post from developer Numman Ali, who highlighted the experimental CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS feature in Anthropic’s Claude Code. When run with tmux’s team mode enabled, the setup automatically spawns multiple AI agents in separate terminal panes — a kind of improvised multi-agent workbench. Ali noted that rather than having one main agent orchestrate the others, he preferred to chat with each agent directly himself, coordinating the team manually.
The setup is clever, and very much a sign of where software development is heading. Claude Code, Anthropic’s terminal-based agentic coding tool, is now writing 100% of its own code — a milestone its creator Boris Cherny confirmed just days ago. The tool has become so capable that Cherny himself stopped opening an IDE entirely for a full month, with AI handling every single line of code he shipped.
But as agents proliferate and the workflows around them grow more complex, tmux grids and terminal panes start to feel inadequate. Karpathy made this point directly on X today.
Karpathy’s Vision: An “Agent Command Center”
“Tmux grids are awesome,” Karpathy wrote, “but I feel a need to have a proper ‘agent command center’ IDE for teams of them, which I could maximize per monitor. E.g. I want to see/hide toggle them, see if any are idle, pop open related tools (e.g. terminal), stats (usage), etc.”
It’s a deceptively simple observation that points to something profound. When you have one AI agent, you prompt it and review its output. When you have a team of them running in parallel — some writing code, some reviewing it, some searching the web, some idle — the cognitive overhead of managing them starts to resemble something much more like managing a team of people than interacting with a single tool.
Anthropic itself has recognized this dynamic. Its recently launched Code Review feature deploys a coordinated team of AI agents to automatically review pull requests — some hunting for bugs, others verifying them, producing a ranked severity list. Managing which agents are running, which have finished, and what they have found is already a coordination problem.
“Org Code”: The IDE As Organizational Architecture
Karpathy went further still in a follow-up post, sharing a well-known diagram depicting the organizational structures of major tech companies — Amazon’s strict hierarchy, Google’s mesh of interconnected teams, Facebook’s cross-functional web, Microsoft’s warring siloed divisions, Apple’s hub-and-spoke model centered on a single leader, Oracle’s legally-layered engineering structure.
His point was arresting: these patterns, long seen as quirks or consequences of corporate culture, are actually forms of what he called “org code.” And unlike traditional companies, agentic organizations can be forked.
“You can’t fork classical orgs (eg Microsoft) but you’ll be able to fork agentic orgs,” he wrote.
This reframes the IDE from a tool for writing software into something closer to an organizational design tool. The way agents are structured, how they communicate, which ones have authority to act and which ones only advise — these are all architectural decisions. And if those decisions are encoded in software, they can be versioned, shared, and remixed just like any other codebase.
Why This Matters For Business
The implications extend well beyond the developer community. As AI dramatically accelerates code output — Google Principal Engineer Jaana Dogan recently noted that Claude Code replicated in an hour what her team had spent a year building — companies face a new kind of question: not just what AI can do, but how to structure the AI doing it.
Anthropic has predicted that developers will shift from writing code to managing AI systems. Karpathy is suggesting the tools to support that shift don’t yet exist in mature form. Tmux is a workaround; what’s needed is purpose-built infrastructure for observing, controlling, and orchestrating fleets of agents across a monitor, a project, or an organization.
The irony is rich. Software engineers have been moving away from IDEs as AI takes over coding. But now, a new class of IDE — one designed not for writing code but for managing the agents that do — may be exactly what the next era of software development requires.
The more things change.