There is an interesting story sitting underneath OpenAI’s latest product launch.
On September 29, OpenAI announced Dots, its new class of always-on AI agents. Within hours, people noticed something peculiar. Type what must surely be one of the most obvious addresses for the product — dot.com — into your browser and you don’t arrive at OpenAI.
You arrive at Grok.
It turned out that xAI had acquired the domain in July, roughly two months before OpenAI announced Dots. Nobody outside the companies seems to know why. There have been rumours about what xAI paid and speculation about whether Musk knew what OpenAI was preparing, but no convincing explanation has emerged.
The internet went wild as usual. A social media post pointing out the coincidence went viral and Musk eventually joined in by reposting the story with two words:
“Dot.com.”
Maybe Musk knew. Maybe somebody at xAI made a spectacularly prescient domain purchase. Maybe it is simply one of those coincidences made irresistible by the people involved.
But there is something fitting about it. Two of the companies racing hardest to build the agentic future somehow found themselves connected by a literal dot.
And once I started looking at what OpenAI had actually launched, I found another one.
Buried inside its description of Dots is a phrase that sounds almost mundane. OpenAI says a Dot can take on “ongoing responsibility”.
I read past it the first time.
Then I came back.
Because “ongoing responsibility” may turn out to be considerably more important than who owns dot.com.
We have spent the last few years watching AI move from answering questions to doing things. Agents can research companies, analyse documents, write and execute code, operate browsers and carry out sequences of work.
In fact, by late 2026, the remarkable thing is how unremarkable creating an agent is becoming.
Consider the Pentagon.
Earlier this year, military and civilian personnel were given access to Google’s low-code Agent Designer. In less than five weeks, they created more than 100,000 AI agents.
These weren’t 100,000 software projects being painstakingly built by engineering teams. People were creating agents themselves to analyse documents, prepare reports and work with data.
One hundred thousand agents. Five weeks.
At some point, abundance changes the question.
If creating an agent is becoming that easy, then creating the agent is no longer the interesting part.
The interesting question is what happens after you’ve created it.
What are you prepared to entrust it with?
Imagine I ask an agent to book my flight to New York. That’s a task. I know what needs doing.
Now imagine I say: look after my trip to New York.
I have barely changed the sentence, but I have completely changed the relationship.
The flight gets cancelled while I’m asleep. A meeting moves. The hotel no longer makes sense. The train from the airport is disrupted. A better flight home appears.
I couldn’t have specified those tasks because they didn’t exist when I gave the instruction.
Something now has to notice what happened, decide whether it matters and work out what should happen next.
At which point our AI agent starts to resemble something we’ve had for a very long time.
A travel agent.
That old phrase suddenly seems more interesting than it used to. An agent was never merely somebody who completed tasks for you. An agent was somebody entrusted to act on your behalf.
That’s what agency means.
Perhaps we called these systems agents before we were really ready to give them agency.
Now we are beginning to.
And the crucial word is entrusted.
We give work to things that are capable. We entrust responsibility to things we trust.
When I entrust another person with something important, I’m not trusting them merely to follow instructions. I’m trusting them when the instructions run out. I expect them to understand what I was trying to achieve, notice what I didn’t anticipate and know when they can act and when they need to come back to me.
A task can be specified.
A responsibility has to survive what you couldn’t specify.
Now move that idea inside a company.
An agent starts by reading invoices and flagging anomalies. Then it starts deciding which ones need attention. Soon somebody asks why humans are still dealing with the obvious cases, so we let the agent resolve those too.
One case needs another system, so we grant access. Another requires permission to make a change, so we grant that. Eventually the agent encounters something nobody anticipated when its original instructions were written.
What should it do?
That is the moment the problem changes.
Nobody held a meeting and decided to hand responsibility to a machine. It arrived one perfectly reasonable permission at a time.
First the agent saw the work. Then it recommended what should happen. Then it acted. Eventually it began deciding when action was needed at all.
Somewhere in there, we stopped merely automating work.
We entrusted responsibility.
And responsibility brings authority with it.
If I tell you to look after something but require my permission for every decision, I haven’t really given you responsibility. So the more responsibility we give an agent, the more freedom it needs to decide and the more authority it needs to act.
That’s where the apparently technical questions suddenly become very human ones.
Who is it acting for? What can it see? What can it change? How far can it go before asking? And when the world changes tomorrow, does the authority we gave it today still apply?
This is where much of my own work in agentic AI now sits. Building an impressive agent is becoming easier. The difficult part begins when you connect it to a real organisation and give it enough authority to be useful without giving it more authority than you intended.
Companies already know how to solve this problem for people.
Your job gives you responsibility, but it doesn’t give you unlimited power. You may be allowed to approve £10,000 but not £1 million. You can see some information but not all of it. Some decisions are yours; others require somebody else’s approval. When something falls outside your authority, you escalate it.
We have spent centuries building organisations around this simple relationship between responsibility and authority.
Now we’re putting machines inside it.
And here is the uncomfortable part.
We can move responsibility to the machine.
We cannot move accountability with it.
If an agent moves money it shouldn’t, exposes confidential information or makes a decision outside the authority it was given, “the agent did it” will not satisfy the customer, regulator or board.
The machine may increasingly decide what needs doing and carry it through.
The consequences remain ours.
Which makes another result from OpenAI particularly interesting.
OpenAI has been testing what happens as agents work through longer chains of activity while trying to remain inside the boundaries intended for them. With five linked tasks, 8.6% of samples were flagged for possible boundary problems.
When the chain doubled to ten tasks, that number rose to 19.7%.
More than double.
What interests me isn’t simply the percentage.
The work lasted longer.
The agent had to keep pursuing the original goal while the situation evolved, without losing the boundary around how it was allowed to pursue it.
And that is exactly what responsibility demands.
Tomorrow isn’t contained in today’s instruction. New information appears. Exceptions happen. Another system becomes relevant. Another agent gets involved.
The goal has to survive what happens next.
So does the boundary.
We’ve spent much of the agent era asking how long an agent can keep working without a human.
“Ongoing responsibility” introduces a harder question.
How long can an agent keep working while remaining inside the authority the human intended to give it?
That, I think, is where the scarce thing is moving.
The Pentagon can create more than 100,000 agents in five weeks. The models will keep improving. Building agents will get cheaper, faster and easier.
But responsibility cannot simply be generated along with them.
It has to be entrusted.
And to entrust it, we need to know who the agent is acting for, what authority it has, where that authority ends, how it can delegate it, when a human must return and who remains accountable when something goes wrong.
Those may sound like infrastructure problems.
What they actually create is trust.
Which brings me back to dot.com.
Steve Jobs famously said you can’t connect the dots looking forward; you can only connect them looking backwards.
Perhaps.
But look at the dots appearing now.
One of the largest organisations on Earth creates more than 100,000 agents in five weeks. OpenAI starts describing agents not merely as things that perform tasks, but as things that take on “ongoing responsibility”. Its own testing begins exposing how much harder boundaries become as the work persists.
And somehow, two months before OpenAI announced a product called Dots, Elon Musk’s xAI bought dot.com.
I still don’t know whether Elon knew.
But the domain may have accidentally given us the perfect metaphor.
The dots are becoming easy to create.
The consequential question is what happens when we start putting them in charge of things.
Because the next boundary is not whether agents can do the work.
It is whether we are prepared to entrust them with what happens next.
And however much responsibility eventually moves to machines, the accountability remains ours.