I have started noticing a different kind of response from AI. It completes the task I asked for, then tells me it spotted something related and dealt with that as well.
That is useful when it understands the objective and stays within sensible boundaries. It is less useful if I cannot see what changed or why. The interesting part for me is learning where to give it room to act and where I still want it to stop and ask.
April’s releases from OpenAI made that model look increasingly temporary. On 16 April, OpenAI expanded Codex beyond coding with background computer use, access to more applications, memory and ongoing repeatable work. A week later it released GPT-5.5, describing a model designed to take messy, multi-part tasks, plan them, use tools, check its work and keep going.
The shift I care about is not another benchmark improvement. It is this: Software is starting to move from being operated to being delegated to.
The old contract with software
Traditional software has an implicit contract. You provide the intent. You translate that intent into a sequence of actions the system understands. The software executes those actions.
A CRM does not usually decide that a customer needs attention, research the account, prepare the response, update the opportunity and coordinate the next action unless somebody has designed an explicit workflow for it.
A spreadsheet calculates brilliantly, but somebody builds the model. A browser can reach almost anything, but a human decides where to click. Software has historically been powerful and passive.
Generative AI began to soften that contract because people could express intent in natural language. Agents push it much further because the system can increasingly translate intent into action itself.
The interface stops being the destination
This has implications for product design. The software industry has spent decades improving interfaces. Menus became graphical. Desktop applications moved to browsers. Mobile reduced complex products to taps and gestures. SaaS companies obsessed over onboarding, navigation and engagement.
Agentic systems create a strange possibility: the best interface may sometimes be the one the user barely visits. If I can state an outcome and the system can use the relevant applications on my behalf, the value moves away from navigating the interface and towards completing the work.
That does not mean interfaces disappear. It means their role changes. They become places to express intent, inspect progress, resolve ambiguity, approve consequential actions and review results. The click path becomes less important than the outcome.
Software used to wait for us. Increasingly, the useful question is what it can finish after we stop clicking.
Computer use changes the boundary
Computer use is particularly interesting because it attacks one of the awkward problems in enterprise automation. Businesses run on messy combinations of modern APIs, old applications, web portals, spreadsheets and tools that were never designed to work together.
Traditional automation often requires explicit integrations. An agent that can see a screen, click, type and navigate software has another route. That route will not always be the safest or most efficient. APIs remain preferable for many reliable, high-volume processes.
But computer use potentially expands the addressable surface of automation. A system does not necessarily need every application to be rebuilt before it can interact with it. That is a big deal in the real world, where technology estates are rarely clean.
Delegation is not automation
Recurring research is one place where I can see the benefit. I do not want to remember to ask the same question every time. I want to explain what I am interested in, have the work happen, and review what comes back. That is a different relationship from opening an application and operating it myself.
My willingness to delegate also depends on whether I can correct the result. For a low-risk, reversible task, asking me to approve every small step can defeat the point. For something consequential, the boundaries need to be much tighter. In either case, I want an account of what happened and the ability to ask why.
I think there is also an important distinction between automation and delegation. Automation says: when X happens, execute Y. Delegation says: here is the outcome I want; work out how to get there within these boundaries.
The second requires much more. The system needs to understand intent, make plans, select tools, deal with exceptions, recognise when it is uncertain and know when to ask for help.
That is why agent reliability matters so much. A workflow that succeeds 80% of the time may look impressive in a demonstration and be unusable for a consequential business process. The more autonomy we give software, the more important evaluation, permissions, auditability and escalation become.
Capability creates the opportunity. Control determines whether we can use it.
SaaS economics may change
There is another consequence worth watching. Many software businesses monetise access to a tool. Seat counts, feature tiers and engagement have been natural metrics because humans are the users.
What happens when agents become users too? An organisation may need fewer people manually operating a system while generating more machine-driven activity through it. Value could migrate towards APIs, transactions, outcomes, data access and agent infrastructure.
Some software companies will benefit enormously because agents make their underlying systems more useful. Others may discover that parts of their interface were only valuable because humans had no alternative way to reach the capability underneath.
I would not assume “agents kill SaaS”. That is too simplistic. But I would assume that every SaaS company should ask what its product looks like when the primary interaction is no longer necessarily a human clicking through screens.
Work gets redesigned around exceptions
The organisational consequence may be even more important. If software can complete larger chunks of routine work, humans move towards judgement, exceptions and accountability. That sounds attractive, but it is not automatically easier. Exception-heavy work can be cognitively demanding. Managers need visibility into what agents are doing. Teams need to know when to intervene. Processes designed around human hand-offs may need to be rebuilt.
Simply inserting an agent into the middle of an existing process can create a faster version of a bad process. The better opportunity is to redesign the process around the new capability.
- What can now happen automatically?
- Where is human judgement genuinely valuable?
- Which actions require approval?
- What evidence should the system provide?
- What happens when confidence is low?
Writing a better prompt helps, but somebody still has to make those decisions about the work.
The new software question
GPT-5.5 will not be the last model to improve computer use. Codex will not be the only agent capable of working across applications. That is precisely why I think the strategic point is bigger than either product. We are beginning to change the basic relationship between people and software.
For decades the question was: What can this software help me do?
Increasingly it becomes: What can I responsibly ask this software to do for me?
The word responsibly matters. Delegation without control is recklessness. Control without delegation leaves much of the opportunity untouched.
The businesses that get this right will not simply bolt agents onto existing software. They will rethink where the human needs to be in the loop at all.
Sources: Codex for (almost) everything · Introducing GPT-5.5