---
title: "A Chatbot Is Not a Coworker"
slug: a-chatbot-is-not-a-coworker
order: 2
author: "Matthias Manoukian"
role: "Co-founder & Design, Otto Softwares"
date: 2026-06-12
status: draft
summary: >
  Chat is a beautiful interface for conversation and a terrible one for
  work. Work has shape — tables, queues, drafts, dashboards — and a thread
  flattens all of it. A design argument for why the agent-in-a-chat pattern
  has a ceiling, and what the interface for autonomous work looks like
  instead.
---

# A Chatbot Is Not a Coworker

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.

## Work 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.

## The 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.

## "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).

## The 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.

## The 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](https://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