When Meta introduced Muse, I was amazed.
It was not simply another model producing better answers. Muse made the idea of a personal AI agent understandable: give it a goal, let it use a browser and connected services, allow it to keep working after the conversation ends, and have it return when something changes or approval is needed.
That already felt like a major step beyond the chatbot era.
Then OpenAI announced Dots, and somehow I felt even more surprised—and much more excited.
The reason is not that Dots appear to do one magical thing that no other agent can do. It is that many capabilities we have watched develop separately now seem to meet in one place: ChatGPT's memory, Codex, connected tools, a cloud computer, optional access to a local computer, recurring work, and rules for when the agent can act or must ask.
For the first time, the phrase AI coworker felt less like marketing and more like an emerging product shape.
Muse broke the chatbot frame
Meta describes Muse as a personal agent that can turn a goal into a plan, coordinate time and resources, open a browser, complete forms, and keep working after its app is closed. It can return for approval before sensitive actions such as sending an email or making a purchase.
What matters here is continuity.
A chatbot waits. It begins when we type and usually stops when it replies. A personal agent can remain attached to an outcome. It can observe that circumstances have changed, continue a multi-step process, or bring the next decision back to us.
That changes the value of AI. The model is no longer useful only during the minutes when we are actively prompting it. Its value can extend into the time when we are doing something else.
Why Dots hit me differently
ChatGPT's Dots are also described as always-on agents, but they arrive with something important: an ecosystem many of us are already using to think and build.
A Dot can begin with context from ChatGPT memory. It can use Codex and connected tools. It has its own cloud computer and can optionally be connected to a local computer. It can work across apps, run scheduled tasks, continue between conversations, and bring results or judgment calls back for review.
That combination is what caught my attention.
I have already experienced how quickly tools such as Codex can turn an idea into a functioning product. We have built small applications, refined them, deployed them, written about them, and connected those stories back to this website. Today, I still initiate and coordinate most of those steps.
A Dot suggests a different workflow.
Today: idea → prompt → result → another prompt → review → repeat With an ongoing agent: goal + boundaries → continuing work → review points → progress
The difference is not merely automation. It is ownership of the next step.
From assigning a task to assigning responsibility
We normally give software commands. We tell it exactly what action to take, or we give a model a prompt and wait for a response.
Responsibility is larger than a command. It means the agent must notice what needs to happen next, decide which steps are appropriate, preserve relevant context, and recognize when it should stop and ask.
OpenAI's own examples reflect that distinction. A Dot might track an API migration until remaining calls reach zero. It might watch customer feedback, identify a repeated request, build and test an improvement, and bring the working change and trade-offs to the engineering team. It might keep a leadership deck current as new product and revenue numbers arrive.
These are not single prompts. They are outcomes that unfold over time.
Agents have acted before. The deeper transition is from completing an isolated action to staying responsible for an outcome between conversations.
The interface is becoming permission
Once an AI can continue without a new message, the prompt is no longer the whole interface. Permission becomes part of the product.
What may it read? Which tools may it use? Can it prepare an email but not send it? Can it change code but not deploy it? Can it make a small purchase within a limit? When should it interrupt? What must always be handed back to a person?
Dots allow rules that distinguish between acting without asking, acting only when pre-approved, asking before acting, and handing an action back to the user. OpenAI also says some account-affecting or information-sharing actions go through additional review and that certain steps remain with the person.
Muse approaches the same problem with a dedicated secure virtual machine, a separate system that reviews actions reaching the internet, approval for sensitive steps, controls over connected services, and an audit trail.
This is encouraging, but it also reveals how difficult the problem is. The smarter and more proactive the agent becomes, the more carefully its authority must be designed.
Why this excites me as a builder
AI coding tools have already lowered the distance between an idea and a working prototype. A person can describe an application, build it locally, expose it to the world, learn from it, and deploy it without waiting for a large team or months of coordination.
Always-on agents could lower a different barrier: the distance between building something once and continuously taking care of it.
Imagine giving an agent a bounded responsibility for one of my experiments:
- Watch for broken links or failed deployments and prepare a diagnosis.
- Collect recurring feedback about ClearFour without changing its core judgment rules.
- Track an article from draft through metadata, link validation, publication, and indexing checks.
- Notice when a dependency or external API changes and prepare a tested update.
- Keep a project log current, while asking before anything public is changed.
None of these requires an artificial CEO. They require patient follow-through—exactly the kind of work that often gets neglected when one person is exploring several ideas.
This could make individual builders far more capable. It could also help small teams behave as if they had deeper operational support. The advantage may not come from one perfect answer; it may come from thousands of small pieces of work no longer being dropped.
The same power creates a larger trust problem
A chatbot can be wrong in one answer. An ongoing agent can be wrong repeatedly while acting on connected systems.
It may misunderstand a broad goal. It may preserve outdated context. It may follow a malicious instruction hidden inside a webpage, document, or message. It may optimize the visible metric and quietly damage the purpose behind it. It may create so many updates that “proactive” becomes another source of attention debt.
Memory creates its own questions. OpenAI says a Dot can form memories from connected apps even without a specific question, and disconnecting an app does not delete information the Dot has already obtained; deleting the Dot is required to remove its own saved memories. That may be useful for continuity, but it deserves deliberate consent and a clear mental model.
Local-computer access is similarly powerful. It begins turned off, and that is the right default. Connecting files, browsers, commands, credentials, messages, and external services turns an AI mistake from an awkward answer into a possible real-world event.
The companies building these systems describe safeguards, isolated cloud computers, permission controls, approvals, and review layers. Those mechanisms matter. They do not eliminate the user's responsibility to choose a narrow scope, inspect important work, and keep irreversible authority with a person.
A coworker—but not a colleague
I like the coworker metaphor because it captures continuity. A Dot may share context, carry work forward, report progress, and ask for a decision.
But the metaphor has a limit.
A human colleague has lived experience, moral responsibility, social judgment, and accountability. An agent does not accept consequences when something goes wrong. It cannot truly own a promise to a customer or understand what a decision means to a family, employee, or community.
So perhaps the better description is persistent collaborator: capable of meaningful work, but operating inside authority and evaluation that remain human.
The new skill may be responsible delegation
Prompt engineering was about asking well. Working with ongoing agents will require something closer to management and systems design.
- Define the outcome without making the mandate dangerously broad.
- Provide enough context while minimizing unnecessary access.
- Separate reversible actions from irreversible ones.
- Decide what evidence is required before work is accepted.
- Create checkpoints for judgment instead of approving everything or nothing.
- Know when to pause, reset, or take the responsibility back.
This is why Dots amazed me more after Muse. Muse made the future of personal agents visible. Dots made me imagine that future connected to the workbench I already use—conversation, memory, code, tools, projects, and the computer itself.
I am excited, but the excitement is not simply that AI can do more. It is that a new unit of collaboration may be emerging.
We may be moving from a world where we ask AI for outputs to one where we give it responsibilities. Learning what should—and should never—be delegated may become one of the defining skills of the next decade.
Sources & further reading: OpenAI: Introducing Dots · OpenAI: Getting started with your Dot · OpenAI: Managing Dots in workspaces · Meta: Introducing Muse