A timeline from chatbots that answer questions to agents that click, type, browse, use software, and eventually own real work.
For most of the history of software, humans had to learn how to talk to computers.
We learned command lines.
Then menus.
Then graphical interfaces.
Then mobile apps.
Then APIs.
Every generation made computers a little easier for us to operate.
AI is flipping that relationship around.
Now we’re teaching the model how to operate the computer.
Not through a special integration.
Not through a carefully designed API.
Sometimes literally the same way you do:
Look at the screen. Move the cursor. Click. Type. Read what happened. Decide what to do next.
That sounds like a small feature.
I think it may become one of the most important shifts in software.
Because once an AI can reliably use a computer, nearly every piece of software we’ve already built becomes part of its toolset.
We spent decades building software for humans
Think about how much infrastructure already exists behind a normal workday.
You might:
open Gmail
check Slack
update Salesforce
pull numbers from Stripe
edit a spreadsheet
research something in Chrome
create a ticket in Linear
make a slide deck
upload a document
schedule a meeting
Each application has its own API.
Some APIs are great.
Some are terrible.
Some don’t exist.
Some require enterprise contracts.
Some expose 30% of what the UI can actually do.
But there is one interface almost every application already supports:
the interface designed for a human being.
The GUI.
That’s what computer use gives AI access to.
The timeline
The interesting part isn’t any single product.
It’s how quickly the abstraction has been moving.
Era
What we gave AI
2022–2023
Conversation
2023–2024
Tools and APIs
2024
Screens, mice and keyboards
2025
Browsers and multi-step agents
2026
Persistent computers and long-running work
Next
Responsibility
Let’s unpack that.
2022–2023: AI could talk
The first big interface was chat.
Human
↓
Prompt
↓
Model
↓
Response
This was revolutionary because natural language suddenly became a general-purpose interface to computation.
But the model mostly lived inside the conversation.
It could tell you how to book a flight.
It couldn’t reliably book the flight.
It could explain how to update Salesforce.
It couldn’t necessarily open Salesforce and do it.
Intelligence existed.
Agency was still missing.
2023–2024: We gave models tools
Developers started connecting models to functions.
tools = [
search_web,
send_email,
query_database,
create_ticket,
]
Now the model could reason:
I need customer information
↓
call CRM API
↓
I need their latest message
↓
call Gmail API
↓
compose response
↓
send email
This was the beginning of modern agents.
And APIs are still usually the best way for an AI to operate software.
They’re fast.
Structured.
Predictable.
Machine-readable.
But there’s a problem.
The world isn’t one giant beautiful API.
Real companies are messy.
October 2024: Claude gets a mouse
Anthropic introduced computer use with Claude 3.5 Sonnet in October 2024.
Instead of requiring a dedicated integration, Claude could inspect screenshots, move a cursor, click and type into applications. Anthropic described it as a way for AI to use software much like a person would.
That changed something fundamental.
The interface became:
Look at what disappeared.
The API requirement.
That’s huge.
December 2024: Google puts an agent in the browser
Google introduced Project Mariner, an experimental agent built around Gemini 2.0 that could reason over browser content and interact with websites through Chrome.
It could interpret text, images, forms and page elements, then click, type and scroll to complete a task.
Now three things were converging:
vision + reasoning + action
And suddenly the browser wasn’t just somewhere the AI retrieved information from.
It became an environment the AI could operate inside.
January 2025: OpenAI launches Operator
OpenAI’s Operator pushed the idea directly toward consumers.
Operator used its own browser and could interact with websites through clicks, typing and scrolling using a model called Computer-Using Agent, or CUA.
The interesting architecture was not:
AI → website API
It was closer to:
AI
↓
vision
↓
GUI
↓
website
The software didn’t necessarily need to know an AI was using it.
From the application’s perspective, something was simply operating the interface.
That opens an enormous amount of existing software to automation.
July 2025: Computer use becomes part of the agent
This is where things started getting more interesting.
OpenAI integrated Operator’s browser capabilities into ChatGPT agent alongside research, code execution and connectors.
Instead of having a dedicated “browser bot,” the agent could decide which environment it needed.
Research something.
Run code.
Open a website.
Edit a spreadsheet.
Use a connector.
Return to the browser.
Continue reasoning.
That gives us a much more realistic architecture:
This is much closer to how humans actually work.
We don’t use one interface for everything.
Neither will agents.
2026: The computer becomes part of the runtime
This year the idea has moved another step.
Google integrated computer use directly into Gemini 3.5 Flash, allowing developers to build agents that can see, reason and act across browser, mobile and desktop environments. Google specifically points toward long-horizon work and professional applications as target use cases.
OpenAI has similarly expanded computer interaction into ChatGPT Work, including a cloud browser that runs on a separate computer and can continue tasks even after the user leaves the conversation.
That distinction matters.
The old model was:
You open AI
→ ask something
→ wait
→ receive answer
The emerging model is:
You give AI an outcome
→ agent gets a computer
→ agent works
→ agent encounters decisions
→ agent asks when necessary
→ agent continues working
→ outcome appears
That’s a completely different product category.
But mouse-and-keyboard AI isn’t the end state
Here’s the part I find most interesting.
I don’t think AI clicking buttons is the ultimate interface.
It’s a bridge.
Humans created GUIs because humans need visual interfaces.
Agents don’t.
If an application exposes something structured, the AI should probably use that instead.
So the future agent stack likely looks more like:
Use an API when one exists.
Use a structured site tool when available.
Use the GUI when necessary.
This is already beginning to happen. OpenAI’s desktop browser, for example, supports site tools based on WebMCP so an agent can work through structured functionality supplied by a website instead of relying entirely on clicks and visual interpretation.
That’s fascinating.
We may be watching the web evolve from:
websites designed for humans
to:
websites designed for humans and agents.
Computer use solves the long tail
APIs solve the happy path.
Computer use solves the weird stuff.
Imagine an operations employee.
Every Monday it needs to:
Open vendor portal
↓
Download last week's CSV
↓
Open internal dashboard
↓
Compare totals
↓
Investigate mismatches
↓
Update spreadsheet
↓
Create report
↓
Email finance team
↓
Escalate discrepancies
Building six perfect API integrations might take weeks.
A sufficiently capable computer-using agent can potentially interact with the software already there.
That is why computer use matters so much for automation.
It makes the existing software world backward-compatible with agents.
The architecture of a computer-using employee
If I were building one today, I wouldn’t make the model blindly click around.
I’d build something closer to this:
And around that loop:
Permissions
Approvals
Identity
Audit logs
Budgets
Rate limits
Policies
Human escalation
That’s the difference between a cool demo and software I’d actually trust to run inside a company.
The hard problem is no longer clicking
The impressive demo is:
“Look! It opened Chrome!”
That’s not the hard part anymore.
The hard problems are increasingly:
What is the agent allowed to do?
Reading a CRM and deleting the CRM are both technically “computer use.”
Very different permissions.
How does it know when to ask?
Draft email → autonomous
Send email → maybe approval
Refund $20 → perhaps autonomous
Refund $20,000 → absolutely not
How does it recognize failure?
Humans do this constantly.
You click Save.
Nothing happens.
You notice.
You try again.
You investigate.
Agents need the same feedback loops.
How do we defend against hostile environments?
A web page can contain instructions designed to manipulate an agent.
Prompt injection becomes much more serious when the model has permission to act, not merely answer. OpenAI explicitly identifies prompt injection and model mistakes as major computer-use risks, while Google’s early Mariner work kept humans involved for sensitive actions.
How do we know what happened?
Businesses will need:
What did the agent do?
Why?
Which information did it access?
Which actions required approval?
What changed?
Who authorized it?
Computer use without observability is chaos wearing a robot costume.
There is a bigger shift hiding underneath this
We usually describe computer use as:
AI can now use software.
I think that’s underselling it.
The deeper shift is:
Software is becoming an environment for AI workers.
That’s different.
The browser becomes their office.
APIs become their machinery.
Credentials become their keys.
Memory becomes institutional knowledge.
Schedules become working hours.
Triggers become assignments.
Guardrails become management.
And a computer becomes something closer to their workstation.
The progression looks obvious in hindsight
Look at the sequence.
Every step removes another piece of work the human previously had to perform.
The chatbot says:
Here’s how.
The assistant says:
I’ll help.
The agent says:
I’ll do the task.
The next generation says:
I’m responsible for this.
That’s the transition I’m watching.
The next interface may be responsibility
For decades the fundamental primitive in software was:
the application.
Then AI made the primitive:
the conversation.
Agents are moving us toward:
the task.
But I think there’s another abstraction above the task:
responsibility.
Instead of saying:
Find 50 prospects.
You say:
Own prospecting.
Instead of:
Check support tickets.
You say:
Keep first-response time under ten minutes.
Instead of:
Prepare my Monday report.
You say:
Keep me informed about the business.
Then underneath that responsibility, the agent decides:
when to wake up
what information to gather
which tools to use
what actions to take
what needs approval
when to retry
when to escalate
what to remember
That’s a much bigger idea than computer use.
Computer use is simply one of the technologies that makes it possible.
My timeline from here
This part is prediction, not history.
2026 — Agents get computers
Computer use becomes a standard tool alongside APIs, code execution, search and connectors.
2027 — Agents get identities
Dedicated accounts, credentials, budgets, permissions and audit trails become normal.
2028 — Agents get responsibilities
Companies stop deploying agents primarily for individual prompts and start assigning them persistent areas of work.
2029+ — Software becomes agent-native
Products increasingly expose machine-oriented interfaces alongside human GUIs.
The question changes from:
“Does your product have an API?”
to:
“Can an agent work here?”
And that’s the part I’m building around
This is one of the ideas behind Roster.
I’m less interested in making another place where you can chat with an AI.
I’m interested in what happens after the model gets:
a job, memory, tools, a computer, a schedule, guardrails and responsibility.
Because the important milestone isn’t when AI can click every button on your screen.
It’s when you stop thinking about the buttons entirely.
You assign the outcome.
The work gets done.
And one morning you realize:
You didn’t ask the AI to do it this time.
It already knew it was responsible.
The Computer Is Becoming an API
We spent decades teaching humans how to use computers.
We’re now teaching computers how to use themselves.
And I suspect that transition will change software more than another generation of prettier chat interfaces ever could.
The future of AI isn’t just better answers.
It’s work getting done.
I’m building Roster around this idea: AI employees with real responsibilities, tools, memory, schedules and computer access. If that future sounds interesting
Top comments (1)
The "responsibility" abstraction is the piece that clicked for me. Most builders are still thinking in tasks — but you're right that the real ceiling is outcome ownership. The shift from task-givers to outcome-assigners changes product design from the ground up. Roster sounds like it's building toward exactly that. Following closely.