AI agents have been discussed for a while.
But there is a major difference between an AI that generates text and an AI that can actually operate software.
GPT-6 Astra is an interesting step in that direction.
OpenAI introduced Astra in September 2026 with a focus on coding, research, computer use and complex multi-step work.
The important part is not simply that the model is more capable.
It is that the model is increasingly designed to do things, not just describe how things could be done.
From generating answers to performing tasks
Traditional LLM usage often looks like this:
Human
↓
Prompt
↓
AI
↓
Answer
↓
Human performs the actionComputer-using agents change the workflow:
Human
↓
Goal
↓
AI agent
↓
Computer interaction
↓
ResultThe difference is significant.
The model can potentially navigate interfaces, work with documents, interact with applications and perform multiple steps.
That moves AI closer to an execution layer.
Why computer use matters
Software is everywhere.
Businesses already use dozens of applications:
- CRM;
- accounting;
- ERP;
- spreadsheets;
- email;
- project management;
- support tools;
- internal dashboards.
Many processes still require humans to copy information from one system to another.
Computer-use agents attack precisely this problem.
Instead of building a custom integration for every application, an agent can potentially interact with the interface itself.
That does not make APIs obsolete.
In fact, APIs will usually remain preferable when they exist.
But computer use creates another option when integration is difficult, unavailable or too expensive.
The developer’s job changes
This evolution also changes what software developers need to build.
The question is no longer only:
How do I build an application?
It becomes:
How do I build an application that humans and AI agents can safely operate?
That means thinking about:
- permissions;
- predictable interfaces;
- structured data;
- validation;
- audit logs;
- error recovery;
- authentication;
- human approval;
- idempotency.
An agent that can click a button is not automatically an agent that should be allowed to click that button.
Agents need boundaries
This is probably the most important part.
Giving an AI access to a computer introduces a completely different risk profile from asking it to write an answer.
A useful agent should have clearly defined boundaries.
For example:
Read customer data → allowed
Prepare a quotation → allowed
Modify quotation → requires approval
Send quotation → requires approval
Delete customer → forbiddenThe intelligence of the model is only one part of the system.
The surrounding architecture determines what the agent is actually allowed to do.
Where I see the opportunity
For business software, the interesting use case is not necessarily a general-purpose autonomous agent.
It is a domain-specific agent.
An agent that understands:
- customers;
- products;
- quotations;
- invoices;
- stock;
- interventions;
- payments;
- business rules.
The narrower the domain, the easier it becomes to define what the agent should and should not do.
The next generation of software
I think we’re moving from:
Software with AI features
towards:
Software operated partly through AI agents.
That’s a meaningful architectural shift.
The UI doesn’t disappear.
APIs don’t disappear.
Business logic doesn’t disappear.
But another layer appears between the user and the software:
User
↓
AI Agent
↓
Business Logic
↓
Applications / APIs / DatabaseFor developers, that means agent design is becoming a software engineering problem.
And that’s probably more important than the latest benchmark score.
Further reading :
