OpenAI dots Security: When Every Dot Inherits Your Access

- Share:





3366 Members
TL;DR: A dot is an always-on agent in ChatGPT with its own cloud computer, connections to thousands of apps, and the ability to hand work to Work and Codex. OpenAI's enterprise docs are clear that in a connected app a dot "inherits the permissions of the account its owner authorized." Auto-review, admin RBAC, and Activity View are real controls; keep them on. The fleet problem is that one request can become several agents, each with the owner's reach and its own policy. Fix it with an identity per agent that is scoped below the owner, a policy check on every call, approvals at risky steps, and one log. Our Software Factory Security model lays out those controls.
OpenAI introduced dots on September 29, 2026 as "always-on agents built to handle everything." Each dot has its own cloud computer and browser, learns from feedback, and works toward your goals around the clock. Through plugins a dot can connect to over 4,000 apps. You can reach it in ChatGPT, Slack, and Teams, and you can give it permission to connect to and use your laptop.
The Help Center guide adds that a dot starts with context from your ChatGPT memory, that you choose what it can do on its own, and that you can pause it at any time.
OpenAI is also explicit about where this is heading: it describes a future of "teams of dots working together on your behalf," and a preview of "specialist dots with their own identity for access management."
The enterprise security guide is detailed, and a few controls stand out:
For one agent, that is a reasonable stack.
Two sentences in OpenAI's docs carry most of the risk.
The first: "In a connected app, it inherits the permissions of the account its owner authorized." A dot connected to your drive or CRM can do whatever you can do there. TechCrunch also noted that the controls "aren't granular" and that dots refuse to accept read-only access to cloud drives.
The second is about delegation: a dot "can delegate tasks to Work or Codex," and that delegated task follows its own policy and the permissions of its environment. So one request to one dot can become a chain of agents, each with different rules.
OpenAI's offboarding guidance shows what that means operationally. Pausing a dot stops new work, but a task it already started in a separate Work or Codex thread can keep running and has to be cancelled separately. Connected accounts have to be revoked and verified "in the service that issued it." Activity reporting through the Compliance API runs on a 30-minute p95, which OpenAI describes as reporting timing, "not immediate-stop guarantees."
None of this is a flaw unique to dots. It is what happens whenever an agent acts as a person across many systems, and it gets worse when that person also runs agents from other vendors.
| Fleet risk | How it shows up with dots | Control that fixes it |
|---|---|---|
| Standing access | A dot holds the owner's full permissions in each app | Grants scoped below the owner, per workflow |
| Delegated identity | Downstream apps see the owner | An identity per agent, bound to the delegating human |
| Intent drift | A long-running project wanders from the original ask | Declared intent checked on each call |
| Prompt injection | A shared document carries hidden instructions | Policy outside the model |
| Audit | Records split across ChatGPT, Codex, and each app | One decision log |
An agent that inherits a person's access is a service account with a personality. We compared the two in agent identity vs. service accounts: the missing piece is usually a distinct identity that says which agent acted, for whom, and within what limit.
Intent matters as much as identity. A dot working on "prepare the quarterly brief" has no reason to change sharing settings on a folder, even though the owner can. The authorization question has to include the task: may this agent, acting for this human, in this workflow, do this action on this resource right now?
Software Factory Security was written for fleets of AI coding agents, which is close to where dots came from. As shared in our docs, the model is to give every agent its own identity delegated from a human, deny by default, check every call against policy outside the model, stop risky steps for a person, and keep one decision log.
For a dot and the agents it delegates to, that looks like this:
The Software Factory Security blueprint covers the architecture in depth, and human-agent delegation and the audit trail covers how to record who delegated what.
Pick the connected app where a dot holds the most of your permissions and scope it down, at the app or at a policy layer in front of it. The Software Factory Security page explains each control and where it runs.

Co-Founder / CEO at Permit.io