On 4 November 2026 Microsoft shipped Intelligent Terminal 0.3.3083.0, the largest update since the experimental fork of Windows Terminal launched in June. The release makes a vertical sidebar the default (collapsible with Ctrl+Shift+S), adds live agent status dots, pinning, nested split panes under tabs, global search across open tabs and recent sessions, automatic CLI profile generation for detected agents, and headless mode that keeps a tab’s process tree alive after the window closes.
The product is still an MIT-licensed experimental app that installs side-by-side with stock Windows Terminal. It requires Windows 10 2004 (19041)+ and an ACP-compatible agent CLI (Copilot is the default and can be auto-installed via WinGet). The interesting part for anyone who ships Windows tooling is not the chrome. It is how the agent pane is wired into the existing ConPTY + console host stack and what that wiring costs in process isolation, IPC, and latency.
Architecture that is actually shipping
From the public AGENTS.md and release notes the process model looks like this:
WindowsTerminal.exe (C++ / WinUI) |-- TerminalProtocolComServer (COM, WT_COM_CLSID) |-- SharedWta → wta-master (Rust) → agent CLI pool (ACP over stdio) +-- one wta-helper pane per tab (ordinary ConptyConnection) | +-- helper/master ACP over named pipe +-- session-scoped MCP tools C++ does not speak ACP. The agent pane is just another ConPTY-hosted pane running wta-helper. The Rust wta-master owns a pool of agent CLI processes keyed by identity + execution source + command. Helpers that share a key multiplex sessions through one process. Installed, policy-allowed native agents (except Gemini and Antigravity) stay resident after master startup. Session MCP exposes run_command_in_current_shell, create_workspace, delegate_task_in_new_workspace, and request_user_input but never executes terminal actions itself — it routes to the owning helper.
That is a clean separation. It also means every agent interaction crosses at least two process boundaries (Terminal.exe ↔ helper, helper ↔ master) plus the ConPTY pipe and the ACP stdio stream to the actual CLI.
Where the latency actually lives
For interactive shell use the numbers that matter are the same ones that have always mattered for ConPTY:
- ConPTY input/output pipe round-trip and the console host’s rendering period (typically 8–16 ms at 60–120 Hz, higher if the host is under load).
- Named-pipe ACP between helper and master (local, but still a kernel transition + serialization).
- Agent CLI startup or warm-up if the process is not already resident.
- Model inference time (cloud or local). Local models via OpenAI-compatible endpoints (added in 0.2, still present) move the inference cost onto the machine but do not remove the ConPTY and IPC hops.
Headless mode is the practical win for long-running agents. Closing the window no longer kills the tab’s ConPTY and the agent CLI attached to it; you can reopen later and reattach. That is useful when an agent is mid-build or mid-refactor and you do not want to lose the session state that lives inside the CLI process.
Error detection is still the classic “watch the ConPTY output, hand the failure context to the agent pane” path. Auto-fix is optional and still requires user confirmation for most write operations. Nothing here invents a new low-latency injection path into the shell; it reuses the existing console host.
Practical trade-offs for tool authors
If you are building your own Windows overlay, sidecar, or agent host, the Intelligent Terminal design is a useful reference for what “good enough” looks like in 2026:
- Keep the terminal/C++ side dumb. Speak a narrow protocol (ACP or your own) over a pipe or COM; do not try to teach the WinUI layer about every agent’s tool-calling format.
- Prefer process isolation for the agent runtime. A crash in the CLI or the Rust orchestrator should not take down the host terminal. The helper-per-tab model gives you that for free.
- Resident agent processes win. Cold-starting Claude, Copilot, or a local llama.cpp server on every pane open is still painful. The master pool is the right place for that cache.
- Headless / detachable sessions matter more than fancy UI once agents run longer than a single command. Users will close windows; the work should not die with them.
- ConPTY remains the bottleneck for anything that must appear in the same pane as the user’s shell. If you need lower latency than the console host can deliver (sub-10 ms paint or injection), you are better off with a separate overlay surface that does not go through ConPTY at all.
A minimal check that the agent is even present still looks like the usual WinGet / registry probe plus an ACP handshake over stdio:
# Detect and install default if missing winget list --id GitHub.Copilot 2>$null if ($LASTEXITCODE -ne 0) { winget install --id GitHub.Copilot --exact } # Then the Terminal settings JSON (simplified) points the pane at it # "acpAgent": "copilot" # "agentPanePosition": "bottom" # "autoErrorDetectionEnabled": true Custom agents are just custom:<name> plus a command line. Local models are a Base URL + Model ID on the BYOM provider. Both paths still land in the same ConPTY + named-pipe hop.
What this does not solve
Intelligent Terminal is excellent for the “I have a shell and an agent next to it” workflow. It does not magically give you a low-latency audio overlay, a dual-stream capture path, or a way to inject text into an arbitrary call application without fighting focus and DPI. Those problems remain outside the terminal process tree.
The 0.3 sidebar and headless mode are real quality-of-life improvements for anyone already living in agent-driven terminal sessions. The architecture underneath is still the same ConPTY + multi-process ACP design that has been shipping since 0.1. If you are measuring end-to-end latency from keystroke to agent response, budget for the console host period and the pipe hops first; the model is usually not the only term.
I'm building Talkaside, a Windows app for job interviews and calls in another language.
Drafted with AI assistance from this project's code and logs.
