Why we built autonomous software, not an agent

When we started building Otto, the default in the market was obvious: make it a chat agent. Drop a message box on the screen, let people type what they want, have a model do it. Everyone was doing it. We tried it, lived with it, and concluded it was the wrong shape for this problem.

The distinction we care about isn't agent-versus-not. It's the interface. An agent is something you operate by messaging — you describe what you want and wait for it to come back. Autonomous software is something that runs the work continuously and gives you a surface to watch and steer it. Otto is autonomous: it researches, plans, writes, and sends on its own, and your job is to direct it, not to dictate every step into a text box.

Three properties of outbound made that choice for us.

1. Outbound is multi-threaded

Outbound is never one thing. You're running a campaign to ops leaders at mid-market SaaS, another to agency founders, a third you're about to launch into a new vertical. Each has its own list, its own message, its own follow-up state, its own results coming in at different speeds. They're all live at once.

A chat thread is a serial interface. It's a single line of conversation, one message after another. Asking it to hold three campaigns in flight means constantly re-establishing context — "the agency one, not the SaaS one" — and hoping the model kept track. That's a parallel problem forced through a serial straw.

Software with a real surface shows you all your campaigns at once: who's in each, what's sent, what came back. You glance and you know. You don't interrogate a bot to reconstruct the state of your own pipeline.

2. Outbound runs on tables, and chat is bad at tables

Underneath every campaign is structured data: companies, contacts, the reason each one was picked, enrichment fields, send status, replies. It's a database. The natural way to work with a database is a grid — you scan rows, sort a column, fix a wrong title in place, drop ten accounts that don't fit, multi-select and act.

Try doing that through chat. "Remove the third one. No, the other third one. Change the title on the account below it." It's painful, it's error-prone, and you can't see what you're operating on. Prose is a terrible pointer. Structured data wants direct manipulation — a table you edit, not a description you dictate.

So Otto puts the data where you can see and touch it. The model does the heavy lifting of building the list; you correct it the way you'd correct any spreadsheet — directly, in a grid, in a second.

3. Editing copy in chat is slower than editing copy

The third surface is the writing. Outbound is copy: subject lines, opening lines, the sequence, the follow-ups. When a line is almost right but not quite, the fastest fix is to click into it and change the word. The slowest fix is to describe the change to a bot and wait to see if it understood.

"Make the second sentence warmer but keep the CTA and don't touch the subject" is more keystrokes than just rewriting the second sentence. Direct manipulation beats instruction for text you already have in front of you. A chat agent turns a two-second edit into a negotiation.

Otto writes the outreach for you — but it hands you the actual text in an editor, not a transcript. You tune the words you want to tune and leave the rest. The model drafts; you have the pen.

Autonomous is not unaccountable

There's a fair worry hiding in the word "autonomous": does it mean the software goes off and does things you can't see? The opposite. The reason we don't lean on chat is precisely that we want the work visible — laid out in views you can read at a glance, not buried in a scrollback you have to reread.

Otto runs on its own, but it runs in the open. You can see every campaign's state, every account it picked and why, every email before it goes out. And because it's acting on your domain reputation and your name, it asks before it does the things that matter. Autonomy is about removing the busywork, not the oversight.

Where chat does belong

None of this is anti-chat. Conversation is a wonderful interface for open-ended thinking — brainstorming a new angle, asking a question, talking through a strategy. Otto has a place for that. What chat is bad at is being the only surface, the one you have to funnel multi-threaded, data-heavy, copy-heavy work through. Use a conversation for the conversation. Use software for the work.

The takeaway

We didn't build a bot you talk to. We built software that runs your outbound and shows you its work — a board for your campaigns, a grid for your data, an editor for your copy — with a model doing the labor underneath. That's what autonomous means here: the work runs itself, and you stay in control of the parts that are actually yours to decide.