For about thirty years, every product ever shipped made the same quiet assumption: a human is going to operate this. A screen. A cursor. A pair of eyes. The interface was the product. We spent careers optimising funnels, onboarding flows, and the exact shade of a button — all of it aimed at a person clicking.
That assumption is dying, and faster than most people building software have noticed.
The thing using your product isn't a person anymore
The next user of your product increasingly isn't a human. It's an agent, acting on someone's behalf. Your customer described what they wanted, delegated the task, and went to lunch. The thing that actually shows up to use your software is a model.
If your product can only be driven by a human clicking through a UI, then to that agent — and to the person who sent it — your product effectively doesn't exist. It can't be reached. It's behind a door only a human hand can open, in a world where fewer and fewer hands are doing the opening.
So we made a rule
Every product that comes out of The Hopium Lab is MCP- and CLI-enabled from day one.
Not as a developer feature bolted on in year three when an enterprise client asks. As a first-class surface, equal in status to the UI. The principle is blunt:
If an agent can't drive it, it's half-built.
In practice that means three things ship together, not in sequence:
- An MCP server, so any agent can discover what the product does and call it directly.
- A CLI, so it composes — it slots into a pipeline, a script, a cron job, another tool.
- An API that is the product — with the UI as one of several heads on the same body, not the body itself.
"So you don't have to"
That's the whole promise, and it's worth being literal about it.
You don't open the hotel revenue dashboard — your agent pulls the numbers, makes the call on tonight's rate, and tells you what it did. You don't fill in the form — you say what you want and the agent fills it. You don't check seven tools every morning — one agent checks them for you and hands you the two things that actually need you.
The product still runs. You're just no longer the one clicking it.
The UI doesn't die — it demotes
This isn't the end of interfaces. It's a demotion.
The UI becomes the place you go when you want to look — to inspect, to trust, to enjoy — rather than the only door into the thing. The real asset was never the interface. It was always the capability sitting behind it. We're just finally building products where that capability is exposed directly, instead of trapped behind a screen built for hands.
Agent-to-agent isn't a sci-fi slide. It's a Tuesday. Models got good enough to be trusted with real tasks, and a shared protocol gave them a common way to reach for tools. The products that speak it become usable by the layer that's increasingly doing the choosing. The ones that don't go quietly invisible.
And yes — this site is heading the same way. The words you're reading live as plain markdown that an agent can write and publish without touching a line of code. Build the thing so the machines can use it, and the humans get their time back.
That's not a feature. That's the bet.