The terminal was the first interface.
It will be the last to fall.
Why the command line is the natural home of the agent — and why it must never leave your machine.
We are teaching machines to act at the very moment we are losing the ability to watch. And the surface where they will act with the most consequence is being quietly relocated into other people's clouds.
Every interface got an AI brain except the oldest and most powerful one. The editor got Copilot. The browser got assistants. The command line — where the real power-users and the machines themselves actually live — is still, functionally, a 1970s teletype. It is the last unconquered interface, and it is being lost by default: to cloud, to mandatory accounts, to telemetry, to other people's datacenters.
The terminal is the one place a cloud does not belong.
Your shell is not a text box. It is where your production lives, where your secrets are typed, where your SSH keys, your kube contexts, your cloud credentials, and your judgment all converge. It is the most sensitive surface in computing. The industry's answer was to make that a thin client. We think that is backwards, and we think it is dangerous.
There are two futures. In one, a handful of vendors mediate every command every engineer runs — metered, surveilled, rented. In the other, intelligence is a local capability, like a compiler. AZMX AI is a bet on the second, and a refusal to build the first.
Agents need a body. The terminal already has hands.
The industry is building brains with nowhere to act. Browsers are sandboxes. Editors only edit. The terminal already owns the PTY, the shell, the processes, the filesystem, the network, and every cloud CLI ever written. It does not need permission to do things — that has always been the point of it. That is why the agent's natural runtime is not a new app. It is the oldest one.
Why now
A top-tier fund already bet that the terminal would be reinvented with AI. They were right about the what and wrong about the where. Three forces converged, and all of them point inward:
- Local models crossed the line. Open models on a laptop are now good enough to drive a real agent loop. "Offline" stopped meaning "worse."
- Agent tooling standardized. MCP made tools portable across models. The model became swappable; the interface became the durable layer.
- The cloud door closed. Security-led and regulated organizations are blocking cloud AI for source and shell access. The demand didn't disappear — it went local.
Our moat is what we refuse to collect.
Everyone is racing to centralize intelligence and harvest the data exhaust. On this surface, that instinct is the trap. The data here is so sensitive that the winning move is the opposite one: be the company that architecturally cannot see you. No telemetry. No account. Keys in the OS keychain. One network call on its own, which you can block. That isn't a privacy policy. It's an architecture — and on the terminal, restraint is the durable advantage no data-hungry incumbent can copy without abandoning their own business.
Where this goes
A compiler made the machine build. A shell made the machine do. The next primitive makes the machine reason — locally, accountably, on hardware you own. We are not building a terminal. We are building the place where humans and agents share the controls of a real machine.
It has been sitting in the corner of your screen for fifty years, waiting.