I first saw Microsoft’s Intelligent Terminal at Computex, running on one of Nvidia’s RTX Spark machines. At the time, I had no clue what it was, but it showed a terminal window with an AI agent pane docked to the bottom, diagnosing errors and suggesting fixes in real time. It looked impressive, and they told me that it was using a local Qwen 3.6 35B-A3B model to power it. I later found out what its name was, and I decided to give it a try.
When I got back home, I installed the new Intelligent Terminal on my own PC, and the most interesting thing I learned was that it’s clearly not locked to Copilot at all. I had thought I might need to do some work to get around it, but it was shockingly easy. The reason it works is that the Intelligent Terminal is built on the Agent Client Protocol, or ACP, which is an open standard that lets any compatible AI agent plug into the terminal as a subprocess over stdio.
Granted, it works with Copilot by default, but the agent dropdown also supports Claude Code, OpenAI Codex, Google Gemini, and, crucially for me, Pi, an open-source coding agent that works with just about any model provider, including local ones through llama.cpp or Ollama. I got it running with Qwen 3.6 27B, and it took about five minutes.
Be warned: it’s a version 0.1 release, and you can feel it. It’s incredibly basic, and there’s not much to it yet, but the architecture choices Microsoft made here suggest they’re thinking about local AI as a first-class citizen, even if it’s built to support Copilot first.
It’s the Windows Terminal with an AI pane
It’s all about agents
Intelligent Terminal is an experimental fork of Windows Terminal, announced at Build 2026 in June. It installs as a separate app alongside your existing Windows Terminal, meaning that it doesn’t replace it or touch it. In other words, if you never want an AI agent anywhere near your shell, nothing changes for you. That might sound minor, but it’s the most interesting thing about this release from the point of view of Microsoft.
You see, Microsoft had two options: bundle agentic features into mainline Windows Terminal and reach tens of millions of developers immediately, or ship a separate app and let people opt in. They chose the latter, and you don’t have to dig deep to understand why. Microsoft spent 2025 shoving Copilot into Paint, Notepad, and basically every app with a toolbar, only to spend early 2026 walking it back under an internal quality program reportedly called K2.
The result of that were the Copilot buttons being stripped from Snipping Tool and Photos, and the Notepad icon was relabeled from a generic Copilot badge to “Writing Tools.” Microsoft has since acknowledged the shift in its own May 2026 quality update, describing it as “a broader shift to make AI in Windows more intentional.” Intelligent Terminal applies that lesson from the very beginning, with its agentic capabilities sitting behind a deliberate download, in a separate codebase, where experimental code can’t cause regressions in the stable terminal millions of people depend on.
The interface itself is pretty straightforward. There’s a persistent agent status bar at the bottom of the window, a dockable agent pane you toggle with Ctrl+Shift+. (and position on any side), and an error detection system that lights up an indicator whenever a command fails. If you hit Ctrl+Alt+., the agent loads that specific error with the relevant shell context already attached. You don’t need to copy the error anywhere or explain what you did, as the AI agent can just see it right away. As well, an agent management panel (Ctrl+Shift+/) tracks active and past sessions across tabs, so you can resume a previous workflow without losing context. The Command Palette even gets a prefix mode for sending prompts directly to the agent, and it can spin up work in background tabs so your foreground shell keeps going.
None of this is complicated, and that’s kind of the point, as it’s just a Windows Terminal with an AI pane bolted on. It’s a beautifully simplistic integration, and it works wonderfully well.
Pi and a local model took about five minutes
ACP makes switching agents a dropdown choice
The default agent is GitHub Copilot, and if you don’t have it installed, Intelligent Terminal will offer to grab it for you through WinGet, which is the path Microsoft expects most people to take. It’s the simplest way to get started, and given how early-days it is, it’s probably the most stable way to use it as well.
However, the agent dropdown in the settings menu accepts any Agent Client Protocol-compatible CLI. ACP works a lot like the Language Server Protocol did for language support: before LSP, every editor needed custom integrations for every language server. Before ACP, every agent needed custom code for every editor. ACP solves that by defining a single JSON-RPC 2.0 interface over stdio, so any agent that implements the protocol works in any compatible terminal or editor without custom engineering. Zed Industries created the protocol, JetBrains adopted it, and now Microsoft has shipped it in a terminal. Editors like Zed already use ACP to connect to agents like Claude Code, Codex, and OpenCode, and a lot of different model harnesses support it these days.
Pi is one of those harnesses. It’s an open-source, MIT-licensed coding agent by Mario Zechner that works with any provider, from Claude and GPT to local models through llama.cpp or Ollama. It’s minimal by design, with a harness that gives the model Read, Write, Edit, and Bash tools, and it extends through a community package system. The pi-acp extension, maintained by the community, bridges Pi’s RPC mode to ACP over stdio, which means any ACP-compatible client, whether that’s Zed, VS Code, or in this case, Intelligent Terminal, can talk to Pi without knowing anything about how Pi works internally.
The setup was straightforward as well. I installed the pi-acp extension for Pi, opened Intelligent Terminal’s settings, set the agent to pi-acp, and set my default Pi model in models.json to Qwen 3.6 27B running on my home server through llama.cpp. That was it. Once that was done, I had a Microsoft terminal talking to a community-built ACP bridge, driving an open-source coding agent, backed by a model from Alibaba, working alongside my terminal. I’ve actually had worse experiences with other Microsoft software packages, and I expected this to be a rough setup, to be honest.
The thing is, in practice, Microsoft’s Intelligent Terminal doesn’t care what model you use or who built it. It cares that something on the other end of the ACP pipe can receive shell context and send back responses. If you want to use Copilot, use Copilot. If you want Claude Code, use Claude Code. If you want a local model running on your own GPU with an open-source agent harness, that’s just as possible. All of this is architected by design, and I love that.
Error detection actually saves time
No more copy-paste between terminal and browser
Error detection solves the most tedious loop in terminal debugging: command failures. Typically, you copy the error, you switch to a browser, you paste it into a search, you go through forum posts, you read answers, you switch back, you paste a fix, and you try again. In this case, though, the Intelligent Terminal handles all of that for you.
I tested it by typing nano, an editor that doesn’t exist on Windows, and watching what happened. The command failed with the expected “‘nano’ is not recognized” message, the agent status bar lit up, and when I opened the agent pane, it had already loaded the error context. Pi, running Qwen 3.6 27B, correctly identified that nano is a Linux text editor not installed on Windows, and listed my options: install via WinGet, install via Chocolatey, install via Scoop, or use Notepad or VS Code instead. It didn’t hallucinate a fix, and instead, it understood what had failed, why it had failed, and what I could do about it.
I had it install nano through WinGet, and it worked. I had it list the contents of a directory, and it worked. The agent has four modes: run shell commands, investigate and fix things itself, delegate to another AI agent like Copilot, Claude, Codex, or Gemini, and plain chat, and you can switch between them depending on what you’re doing. Recommendation cards render as interactive buttons in the pane with keyboard navigation, so you’re not typing “yes” into a text field to approve a command. It actually feels like a native terminal feature rather than an LLM jammed awkwardly into a UI.
Other features, like the agent management panel, are genuinely useful once you’re working across multiple tabs. Background agent tasks don’t block your shell, and you can pick up a previous session without re-establishing context. Aside from what I’ve outlined here, though, there’s not much else to say at present. Version 0.1 is basic by design, which in turn means that the feature set is rather basic, too. There isn’t a whole lot of polish, mainly because there’s not a lot to polish. Still, it’s a lot more than I expected from a new Microsoft terminal in 2026.
Having said that, the decisions that went into designing it, like ACP over stdio as the transport layer, a separate opt-in app instead of a forced bundle, and agent-agnostic design from day one, suggest Microsoft is building for a world where local AI is the expected default that users will want to build around. Between RTX Spark hardware, the MXC sandbox for local agents, and now a terminal that treats your choice of model and agent as a configuration option Microsoft seems to think that the future of AI is about choice rather than vendor lock-in. I’ll be honest, it’s more than I expected from the company, and it still has a long way to go even with that. Still, the direction is genuinely encouraging, and I can’t wait to see how it’s expanded over time.
