dots, OpenAI's Always-On Assistant: What Holds Up

By Lazar Milicevic · Published October 28, 2026 · 9 min read

You're probably already running a patchwork: a coding agent in one tab, a calendar nag in another, and a Slack bot someone built over a weekend. OpenAI's new "dots" product promises to fold that into one always-on assistant. Here's what it actually is, what it costs, what the launch coverage confirms, and which parts of the pattern a small team can copy without paying $100+ a month.

What OpenAI actually launched

dots is a personal agentic assistant that OpenAI announced at DevDay on 29 September 2026, powered by GPT-6 Astra, per TechCrunch's launch coverage. You can launch one from Codex or ChatGPT, and you can message it through Slack, Teams and other organizational platforms. Text message support was listed as coming soon.

The most useful framing came from TechCrunch itself: much of what dots does was already possible through Codex and similar agentic harnesses. The new part is the packaging, with a focus on independent, ongoing actions rather than a chat window you open and close.

The route to this product is visible in OpenAI's own release cadence. According to a secondary summary of OpenAI's launch posts, the path ran through the Codex app (2 Feb 2026), "Codex for (almost) everything" (16 Apr 2026), workspace agents (22 Apr 2026) and ChatGPT Work (9 Jul 2026), before dots on 29 Sep 2026. Treat those dates as reported rather than primary-sourced, but the shape is clear: a coding tool gradually became a general-purpose worker, and dots is the point where it got a persistent identity.

Alexander Embiricos, who leads OpenAI's enterprise product team, gave an interview that explains the philosophy. He said he has a human assistant because OpenAI's corporate partners want to deal with a person, and that he never intends to have a meeting with someone else's agent (as republished from the TechCrunch interview by Jingletree). That's worth sitting with. The product's own champion is telling you the agent is a private helper for one person, not a negotiator that represents you to the outside world.

One caveat on sourcing: I couldn't retrieve the original interview or OpenAI's own "Introducing dots" post, so quotes here come from secondary copies. Check the primary sources before you quote anything verbatim.

Pricing and availability: who can use it today

At launch, dots were available in ChatGPT to Pro and Business Premium users in eligible markets, per TechCrunch. Third-party summaries of OpenAI's pricing page give this picture (see Techsifted's review and eesel's explainer):

Three caveats matter before you budget:

1. Pricing is secondary-sourced. OpenAI says prices may vary by country and currency. Check the current pricing page.
2. The $100 Pro tier is disputed. Most write-ups say all three Pro tiers include a dot, but at least one outlet reports inconsistent coverage and says the guaranteed free dot may start at $200. Don't assume; verify.
3. Regional exclusions. Pro users in the EEA, Switzerland and the UK are excluded at launch, while Business Premium covers all supported regions, per eesel. If you're a UK solo founder, that distinction decides which plan you'd even be allowed to buy.

On usage costs: the first dot is included at no extra cost, with an allowance for deeper work and extended limits for the first month after launch. OpenAI said it will share usage terms per plan afterward and hasn't published prices for extra dots or additional output, according to Nerdleveltech. So any cost model beyond the seat price is speculation right now.

There is one useful detail on metering. Chatting with a dot doesn't count toward ChatGPT usage limits, but tasks the dot starts in Codex or ChatGPT Work do count against plan usage (Techsifted). In practice, the conversation is cheap and the work is what you pay for.

Illustrative math (round numbers, not OpenAI's): if a three-person team each took a Business Premium seat at the reported $125 monthly rate, that's $375 a month before any usage overage you can't yet predict. The same money buys a lot of metered API calls and a self-hosted workflow. Whether dots is worth it depends on how much of that team's week is spent on the repetitive work an assistant can actually take.

The permission model: the part worth stealing

The most transferable idea in dots isn't the model. It's the permission design, and you can copy it without buying anything.

OpenAI's launch post says that when you're not actively working with a dot, it uses connected apps only through read-only tools. Those tools can't send messages, change app content, or control the browser or computer (as relayed by Progressive Robot). That's the right default for an always-on agent: when no human is watching, the agent can observe but not act.

Then there's Custom Rules, which let users change how the agent handles supported actions. Secondary coverage (eesel) describes a ladder of behaviors from acting freely to handing the task back to the user. I couldn't confirm the exact number of levels or their names against OpenAI's own launch post, so check that post for the current wording.

Whatever OpenAI's exact labels are, a tiered ladder is a clean pattern for any automation you build. Here's one way to encode it in a workflow config, using four tiers of my own choosing:

# action_policy.yaml: one policy per action, default is the safest tier
defaults:
  unattended_mode: read_only   # no human present -> observe only

actions:
  calendar.read:
    policy: act_without_asking
  email.draft_reply:
    policy: act_without_asking     # drafts are reversible
  email.send:
    policy: ask_before_acting      # human approves each send
  invoice.create:
    policy: act_if_preapproved
    preapproval:
      max_amount_usd: 500          # example threshold, set your own
      known_clients_only: true
  invoice.void:
    policy: hand_off_to_user
  payment.initiate:
    policy: hand_off_to_user       # never autonomous

And a minimal enforcement layer in Python:

from enum import Enum

class Policy(Enum):
    ACT = "act_without_asking"
    PREAPPROVED = "act_if_preapproved"
    ASK = "ask_before_acting"
    HANDOFF = "hand_off_to_user"

def run_action(action, policy, preapproved_check, ask_human, do_it, notify):
    if policy == Policy.ACT:
        return do_it(action)
    if policy == Policy.PREAPPROVED:
        if preapproved_check(action):
            return do_it(action)
        return ask_human(action)       # falls back to asking
    if policy == Policy.ASK:
        return do_it(action) if ask_human(action) else None
    if policy == Policy.HANDOFF:
        return notify(f"Needs you: {action}")

The design choice that matters: a failed pre-approval check degrades to "ask," not to "act." Most real-world agent incidents come from the opposite default.

Where dots disappoint: testing notes and limits

Launch-week testing coverage is worth reading closely because it shows the gap between demo and daily use. According to those reports:

• Privacy controls are coarse. OpenAI says dots have the same privacy controls as ChatGPT, including turning off model training, but TechCrunch found the controls aren't granular and the app can be pushy (Mezha).
• Access negotiation is rigid. In TechCrunch's testing, dots refused to accept read-only access to cloud drives (TechBytes). For a business with a locked-down shared drive, that's a real friction point.
• Timing is unreliable. Dots flagged calendar conflicts and upcoming deadlines, but not always in time. Embiricos said that early in development his dot warned him of a conflict just three minutes before it happened (AI Agent Blog).

That last one is the honest lesson of "always-on." Always-on isn't the same as always-early. A proactive agent that alerts you three minutes before a conflict is worse than a boring calendar rule that fires the night before. Proactivity needs a lead-time guarantee, which you can only get from deterministic scheduling plus an LLM for the judgment part.

For regulated or sensitive work, note OpenAI's own documentation: the Enterprise, Edu and Healthcare beta is opt-in, requires an admin to switch it on, and lacks data residency and strict zero data retention (Nerdleveltech). If your clients' data has residency requirements, that settles the question for now.

What's hype and what's shipped

Sort the claims into three buckets.

Shipped and verifiable:

• A persistent personal agent reachable from Slack, Teams and ChatGPT/Codex
• Read-only connected-app access when you're not actively engaged
• A Custom Rules system for adjusting how the agent handles supported actions (check OpenAI's launch post for the exact options)
• Included first dot on the plans listed above

Reported but worth checking yourself:

• OpenAI states that dots connect to a large ecosystem of apps through plugins, but that is a count of what the ecosystem contains, not a guarantee that your specific tool works with the quality you need. Check OpenAI's launch post for the current figure and test your actual stack.
• The use cases shown at launch are OpenAI examples or anecdotes, not measured results. They're not evidence of ROI.

Future-looking, not shipped:

• Payments. Embiricos said OpenAI is in many conversations with payment processors about letting the agent work with the world (Progressive Robot). Conversations aren't a feature. No payment capability is confirmed as shipped.
• Teams of dots collaborating. OpenAI "envisions" this. It's a roadmap statement.

So if a vendor, consultant or LinkedIn post tells you dots will autonomously pay vendors or coordinate a fleet of sub-agents for your business today, that's not what the launch coverage supports.

Should a small team buy dots or build the pattern?

A quick decision framework, with the trade-offs stated:

Buy dots (or trial it) if:

• You already pay for ChatGPT Pro or a Business Premium seat and the included dot is effectively free
• Your work is mostly personal-productivity: calendar, inbox triage, deadline tracking, code tasks through Codex
• You're in a supported region and your data doesn't need residency or zero retention
• You want to learn what an always-on agent feels like before committing to custom work

Build the pattern yourself if:

• The work is a business process (invoicing, lead follow-up, onboarding), not one person's personal assistant
• You need audit logs, per-action approvals, or integrations with systems dots doesn't reach
• Multiple people or clients touch the same workflow
• You need predictable cost rather than plan-metered usage you can't forecast yet

The hybrid most small teams end up with: a personal assistant for the founder's own calendar and code, and purpose-built workflows for anything that touches customers or money. That split also follows Embiricos's own logic. His assistant is private to him, and the interface to the outside world stays human or tightly scripted.

A minimal always-on workflow skeleton, using the policy layer from earlier, looks like this:

# cron: check every 15 minutes, read-only unless policy allows
*/15 * * * * /opt/agent/run.sh --mode unattended --policy /etc/agent/action_policy.yaml

# run.sh calls this; unattended mode can only read and draft
def tick(events, policy):
    for event in events:                       # new email, calendar change, etc.
        plan = llm_plan(event)                 # LLM decides *what*
        for action in plan.actions:
            tier = policy.lookup(action.name)  # deterministic rules decide *whether*
            run_action(action, tier, preapproved_check,
                       ask_human, do_it, notify)

The split matters: the model proposes, deterministic code disposes. You get the flexibility of an LLM without handing it the keys.

Where BizFlowAI fits

BizFlowAI builds practical AI automations for solopreneurs and small teams. If you're weighing a personal assistant like dots against a purpose-built workflow for something like inbox handling, lead follow-up or invoicing, the tiered approval model above is the pattern we'd recommend when designing it: read-only by default, with every write action explicitly classified and a human in the loop wherever money or customers are involved.

Work with BizFlowAI

If you'd rather have this built for you, that's what we do: production AI automation for solo founders and small teams — agents, integrations, and document pipelines that actually ship.

Request a free discovery call — 30 minutes, we map the highest-ROI automation in your workflow. No pitch deck, just engineering.

More guides like this on the BizFlowAI blog.