There is a deep field of study of the communication interfaces between people and computers, called human-computer interaction (HCI). Keyboards, mice, touchscreens, trackpads, trackballs, and even the Graphical User Interface (GUI) are all products of this lineage.
More recently, there is a movement to “make what agents want”. Steve Yegge recommends paving “the desire path”, which is literally a mode of “making their hallucinations real”. The process is roughly:
- Tell the agent what you want.
- Watch closely what it tries, such as commands, flags or subcommands it guesses.
- Build the thing it tried.
- Repeat until nearly every guess the agent makes is correct.
Many people now are discussing “agent ergonomics” for products. I tend to build CLIs first, and make the agent use sub-agents as synthetic users to find the bugs and make the tool agent-friendly.
So we have decades of work in human-computer interaction and a couple of years of progress in agent-computer interfacing. The final side of the triangle is the least developed: the human-agent interface.

Why chat?
Why did chat explode as the default interface for LLMs and agents? On the technology side, next token prediction proved to be a highly versatile and scalable strategy for generative AI. On the human side, I think it is because chatting is easy. We can be lazy. We don’t need to learn a new interface or think about what we want to accomplish in advance. We don’t need to prepare an agenda for our agents or learn any new skills to ask ChatGPT a question.
Yet chat is extremely limiting - for both the agents and the humans. From an economics perspective, many are raging against “the tyranny of the KV cache”. Alex Zhang is exploring “the best shape of a model”. Much of my excitement around Jev was simply noticing how refreshing it was to have an AI interface that isn’t based on text generation.
Aren't RLMs bad for the prefix cache? Totally! But keep in mind:
— Omar Khattab (@lateinteraction) February 8, 2026
1) RLMs produce (many) much shorter individual LLM calls. Shorter calls *could* be better than cache. Worth testing.
2) Caching is a cost-saving trick. Expanding the expressive power of LLMs takes precedence imo. https://t.co/xwec5glUCU
Code as a “tri-interface”
Code was the first “tri-interface”. User reads and writes code, agent reads and writes code, computer reads and writes code. Perfect symmetry in the interface.
Unfortunately, humans and agents have very asymmetric attention. So while there is a simplicity to code as the “tri-interface”, it is neither scalable nor sustainable for the humans in the equation. While the agents can clearly read and write any programming language now, agents can now generate more code in an hour than a human can review in a month, maybe even a year.
So we need a layer of abstraction. This was the initial motivation of DSPy - to isolate the fuzziness of the LLM as a black box, to hide the plumbing - so that the user can focus on the interfaces, the “signatures”. OpenProse has the same goal yet takes the opposite approach: move everything into fuzzy-land, make the agent itself “compile” the program - and now the user can write a contract in Markdown.
DSPy and OpenProse are not chat, but they are still text. And boy, do my eyes hurt. I think I may have tokenitis.
To LLMs, the entire world is tokens. Text is their life force, their metabolism. They exist to consume and produce tokens. So if we default to their world and their speed and their power and their preferred interfaces, our eyes bleed.
It’s also generally quite frustrating to get agents to have empathy for human users. They leave stray references to the internal source code on external-facing artifacts: emails, presentations, landing pages. They can’t un-read their context, and without explicit affordances and instructions, they will not naturally “look at their work”. Their “experience” is the tokens in and the tokens out. For agents to try to “experience” the artifact as a person might itself be an impossible goal, but at the very least it takes some extra plumbing and prompting to force the agents to meet their artifacts “face to face”.
Agreeing on the human-agent interface
Yesterday I had the thought that maybe I should start every project by first agreeing on the human-agent interface. Maybe by putting this scaffolding in place up front, by setting the “rules of engagement” with the agents in advance, I might spare my future self from unnecessary eye pain and expletives.
There are a few people doing very interesting work in this area, who are being very intentional about agent-user interfaces.
-
Thariq Shihipar — “Unreasonable Effectiveness of HTML”. This was posted at a time when the consensus was to make everything Markdown to help the agents. More recently he’s pushed people to really consider their UI/UX while collaborating with agents:
software factories feel like a temporary problem. the models will learn to build them for you
— Thariq (@trq212) November 16, 2026
the more interesting question to me is how to build a workspace where agents can collaborate with you -
Lucas Meijer — In “Agents in the Cloud,” Lucas explicitly forces the agents to “spend significant effort” thinking about the specific artifact that they want the human user to review. In his recent workshop at AI Engineer Code Summit in SF (hopefully will be posted online soon), this included an example where the agent modified pi, started up tmux and then spun up a terminal session navigated to the exact TUI pane that was edited, as well as a website where the agent ended the session displaying the exact element on the exact page that was changed.
-
Jeremy Howard — Solveit is a notebook-style UI explicitly structured to help users retain autonomy over their thinking and learning, by “working in small, iterative steps, where you are the one driving the direction of your explorations and building”.
Personally, I’m having a blast going “back to my roots” in real-time machine learning, exploring ways I might interact with my computer without seeing or touching it. I shared some of these explorations last week in my presentation for AI Engineer Code Summit in SF. (Video embedded below, and slides can be found at https://recursivedecisionmodels.com/aie-code-sf-2026/.)
I’m still struggling to define and refine these “intentional human-agent interfaces”, to close the final leg of the triangle. It’s hard work. “Chat” has a tremendous gravity to it, both for humans and agents. I can feel that it’s the missing piece of the puzzle for “Operating System One”. (If you put your email at oSo.computer, I’ll let you know when it’s ready to try.)
After reading this far, you might be hoping that I have “the answer” for you. Sorry to disappoint, but there is no easy way out. I’m flailing around and throwing things at the wall just like everyone else. I try to avoid giving advice. I think instead I’ll share my optimism:
Yes, we are tangled up in too many tokens.
And yes, there is a trail to the other side of text.
Let’s hike, let’s bushwhack, let’s share our routes.