---
title: "Self-Driving Software"
slug: self-driving-software
order: 1
author: "Benoit Guivarch, Thomas Maitre & Matthias Manoukian"
role: "Founders, Otto Softwares"
date: 2026-06-12
status: draft
summary: >
  The next wave of AI is not a smarter chatbot. It's the software your team
  already runs on — outbound, social, ads, CRM — rebuilt to operate itself.
  We call it autonomous software. This is the manifesto.
---

# Self-Driving Software

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.

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

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

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

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

## What this changes

Three downstream consequences, each of which gets its own essay:

1. **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.*)
2. **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.*)
3. **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.*)

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