Every few years, software changes what it asks of you.
First it asked you to install it. Then SaaS asked you to log in. Then AI asked you to prompt it. Each wave kept one thing constant: you were the operator. The software held the records, the buttons, the dashboards — and you spent your day clicking through them to get the work done.
We think the next wave drops that assumption. The next wave of AI is self-driving software: the tools your team already runs on, rebuilt to operate themselves. You set the destination and let it drive — or take the wheel whenever you want.
This essay is the argument for why that's the shape of what's coming, why it isn't the same thing as "an AI agent," and why we're betting our company on it.
01The argument in three beats
1. Real work needs more than a thread
Work doesn't happen in a stream of messages. Slack isn't where you do it, and neither is a chat assistant — even a brilliant one, even with an MCP server or an API bolted on.
When you actually do a job, you need to see it: a table for your lead list, a doc for your sequence, a dashboard for your numbers, a queue for what needs your approval. You need to sort it, edit one cell, compare two versions, scan a hundred rows in a glance. A conversation can describe all of that, but a description of a table is not a table.
Chat is a wonderful interface for talking. It is a terrible interface for working. Real work lives in surfaces you can read and edit.
2. Software is the right interface for work
Here's the thing the AI industry keeps rediscovering from first principles: we already solved the interface problem. That's what Instantly and Lemlist, Buffer and Hootsuite, Salesforce and HubSpot are.
Teams run their work on these tools because everything is in one place — the records, the surfaces, the actions, the history — all shaped the way the work actually flows. An outbound tool knows what a sequence is. A CRM knows what a pipeline stage is. Decades of iteration went into matching software to the structure of each job.
As an interface for getting work done, software is as good as it gets. The problem was never the software. The problem is that it needs a human to operate it.
3. So the software should do the work
If the work really lives inside the software, that's where it should get done.
A chatbot reaching in through an API is always one step removed: it has to ask for state, wait for answers, act through a keyhole, and hope nothing moved in between. The software itself has no such problem. It already holds every record, every action, every bit of state. It is the one thing in the stack with everything it needs to do the job.
So instead of putting an agent on top of the software, you build the autonomy into it. Instead of operating it by hand, you let it run itself.
That's autonomous software. Not a copilot. Not an assistant. The tool itself, doing the job natively, across the same tables, docs, and dashboards you'd use yourself.
02The levels of autonomy
Driving has a vocabulary for this, and it maps almost perfectly. Here is the same ladder for business software:
| Level | Driving | Business software | Who does the work |
|---|---|---|---|
| L0 | Manual | Classic SaaS. Every record created, every button clicked by a human. | You |
| L1 | Cruise control | Automations & macros. Zapier triggers, email scheduling, saved filters. | You, with shortcuts |
| L2 | Driver assistance | Copilots. AI drafts the email, suggests the reply — you steer constantly, hands on the wheel. | You, assisted |
| L3 | Conditional autonomy | Agents under supervision. The system runs multi-step jobs, but escalates often and needs a human watching the chat. | It, babysat |
| L4 | High autonomy | Autonomous software. You set the destination — a goal, a budget, the guardrails. It researches, decides, executes, and reports. You watch, steer, or override at will. | It |
Almost everything sold as "AI" today is L2 — a copilot bolted onto L0 software. The agent frameworks racing ahead right now are L3: impressive demos that still need a human in the loop of every loop.
L4 is different in kind, not in degree. At L4 the question changes from "what should I tell it to do next?" to "is it driving where I want to go?" — and that question is answered by looking at a dashboard, not by reading a transcript.
03The steering wheel
Autonomy without control is a demo, not a product. Nobody hands their pipeline, their brand, or their ad budget to a black box — and nobody should.
So autonomous software comes with a steering wheel, and the steering wheel is not a metaphor. It means, concretely:
- You can always see what it's doing. Every action lands on a surface you can read: the play it built, the leads it found, the email it's about to send, the budget it wants to move.
- You can always edit by hand. It's your software. Change a cell, rewrite a sequence, pause a play. The system treats your edits as the new ground truth, not as interference.
- You choose the autonomy level per decision, not per product. Low-stakes actions can run on auto while high-stakes ones queue for approval. Sending a routine follow-up and reallocating a month's budget should not require the same trust.
- Take the wheel or let it drive — at any moment, in either direction.
This is the part the "fully autonomous agent" crowd gets wrong and the "human in the loop" crowd gets backwards. The goal isn't maximum autonomy or mandatory supervision. The goal is a vehicle you trust enough to stop watching.
04One autonomous software per job
We're building this as a fleet, one product per job:
- Otto Outbound — the outbound stack (think Instantly, Lemlist, Clay), rebuilt to run itself. Drop a URL: it researches the market, builds the plays, finds the leads, writes the sequences, and keeps the pipeline full. It's live today.
- Otto Social — Buffer and Hootsuite that post themselves. Owns your presence on X and LinkedIn: drafts, schedules, replies, joins the conversations that matter.
- Otto Ads — the ads manager that manages itself. Picks the creative, sets the budgets, kills the losers, scales the winners.
- And every job after that. CRM, support, finance ops. If a person spends their day clicking through software to do it, it's on the roadmap.
Why a fleet and not one mega-agent? Because the jobs are different, and the software's shape should match the job — that was beat two of the argument. A sequence editor and an ad-budget dashboard are different surfaces because outbound and ads are different work. Autonomy doesn't erase that; it inherits it.
05What this changes
Three downstream consequences, each of which gets its own essay:
- The interface changes. Chat assistants stop being the destination and become, at most, one way to talk to your software. (A Chatbot Is Not a Coworker.)
- The incumbents can't follow. Their architecture assumes a human session and their revenue assumes a human seat. Autonomous is something a company becomes, not a feature it ships. (Why the Incumbents Can't Ship This.)
- The pricing changes. When the software does the work, charging per human login measures nothing. You pay for outcomes. (The End of the Seat.)
And one consequence that points forward rather than down: autonomous software is also where other AIs will come to get real work done. Same software, same API, no clicking required. (Software for AIs.)
06See it drive
Theses are cheap; demos are not. Otto Outbound is live, free, and needs no account. Drop your website URL at outbound.ottosoftwares.com and watch it research your market, build the plays, and write the outreach — in about the time it took to read this section.
Set the destination. Let it work.
— Benoit, Thomas & Matthias