I design interfaces for a living, so let me start with a confession: chat is one of the best interfaces ever made. It has no learning curve. It forgives typos, half-thoughts, and missing context. It's how humans already talk to each other. When LLMs arrived, putting them behind a text box was the right call — for conversation.
Then the industry decided that since chat was the door, chat must also be the room. Your analyst is a thread. Your SDR is a thread. Your marketing team is a thread with tool calls. I think this is one of the great design wrong-turns of the decade, and I want to explain why with a designer's argument rather than a technologist's.
01Work has shape
Look over the shoulder of anyone doing real knowledge work and you'll see the same thing: not sentences — structures.
A salesperson works a list: a hundred accounts, sortable, scannable, with state per row. A marketer works a calendar and a draft. An ops person works a queue. A founder works a dashboard. The genius of good work software was never the features; it was that the interface matched the shape of the work. A pipeline looks like a pipeline. A sequence reads top to bottom like the days it spans.
Shape is not decoration. Shape is how you think. You spot the outlier because the column lines up. You catch the bad email because the draft sits next to the other drafts. You notice the trend because the chart moves. Tables, boards, calendars, queues — these are cognitive prosthetics sharpened over forty years of interface design.
A chat thread has exactly one shape: a stack of paragraphs, newest at the bottom. Pour any kind of work into it and it all comes out the same — flattened into prose, scrolling away.
02The transcript problem
Here is what working "in" a chat agent actually feels like, hour by hour.
You ask for a list; it writes you a paragraph that contains a list. You want to change row 14, so you describe row 14 in words, and it regenerates the whole thing, hopefully changing only what you meant. Yesterday's good version is now four screens up, interleaved with apologies. There is no hover, no sort, no diff, no select-and-edit — every interaction is mediated by composing prose about the thing instead of touching the thing.
Notice what happened: the agent didn't remove the operator's work, it changed your job title. You used to operate software with direct manipulation — the most important idea in interface design since the screen. Now you operate a model with descriptions. You've been demoted from driver to dispatcher, narrating instructions through a radio and hoping.
MCP and tool calls don't fix this, because they fix the wrong end. They give the model better hands while leaving you in the transcript. The agent can now touch the real table; you still can't. The human is the only one left without an interface.
03"But it talks to my tools"
The standard rebuttal: the chat assistant is just the front door, the real work happens in the connected apps. This quietly concedes my whole argument. If the work happens in the software, and the results must be inspected in the software, and corrections must be made in the software — then the thread is just a slow, lossy remote control for the software. A keyhole with excellent manners.
And a keyhole is the wrong place to supervise from, which matters more every month as the models get more capable. The better the agent, the less the bottleneck is doing and the more it is verifying. Verification is a reading problem, and reading is a layout problem. You verify a hundred leads with a sortable table in thirty seconds; verifying them in a transcript is homework. Chat optimizes the part of the loop that's shrinking (instructing) and starves the part that's growing (inspecting).
04The interface for autonomous work
So what's the alternative — more dashboards, hold the AI? No. The alternative is autonomous software: the autonomy lives inside the tool, and the tool keeps its shape.
When we built Otto Outbound, the design brief was never "make a chatbot that does outbound." It was: make outbound software where the work arrives already done — and where a human can read, judge, and override everything at a glance. That brief produces a very different interface:
- Surfaces first. The system's output lands as the real thing: a play with a thesis, a table of accounts and contacts, a sequence laid out step by step, an inbox of replies. You read work the way you've always read work.
- Glanceable state. "What is it doing, and is it working?" must be answerable in five seconds from a dashboard — not reconstructed from a scrollback.
- Direct manipulation everywhere. Every artifact the software produces is hand-editable in place, and your edit is ground truth. Rewrite the subject line; it learns the register. No prompt required — though if you'd rather type "make it shorter and less formal," there's a box for that too. Conversation as one verb among many, not as the room.
- Approval as a first-class surface. The queue of things awaiting your judgment — this send, this budget move — is a designed object with stakes attached, not a "shall I proceed?" buried in a thread.
The irony is that this is less novel-looking than the chat future. It looks like… software. Good software, with the operator's chair empty and a steering wheel you can grab. I consider that a feature. Forty years of interface evolution were not a mistake to be flattened into a text box; they're the foundation the autonomy should stand on.
05The coworker test
Here's the test I keep coming back to. A real coworker doesn't narrate their keystrokes into your DMs all day and wait for "looks good" between each one. A real coworker ships work into shared surfaces — the doc, the board, the pipeline — and you review it there, asynchronously, at the level of outcomes.
Judged by that standard, a chatbot is not a coworker. It's a very talented intern permanently trapped in your messages app.
Autonomous software passes the test trivially, because it is the shared surface. The work shows up where work lives. You look when you want, steer when you must, and otherwise let it drive.
Don't take my word for it — judgment by demo is the only honest kind. Drop your URL at outbound.ottosoftwares.com and notice, when the research and the plays and the sequences appear, that nothing about it feels like a conversation. It feels like opening the tool and finding the work already done.
That feeling is the product.
— Matthias