OpenAI Dots are the headline from DevDay this week, and if you build software for clients, you'll get asked about them soon. Dots are always-on agents that keep working in the background while you do something else. OpenAI launched them on Tuesday, September 29, 2026, next to a cheaper model called GPT-6.1 Sol. I've read the coverage and here's my honest take for agencies.

Short version: the tech is interesting, the packaging is cute, and the risk sits in permissions. Let's go through it.

What OpenAI Dots Actually Are

According to TechCrunch's report, OpenAI calls Dots "remarkably capable, always-on agents built to handle everything." They're powered by GPT-6 Astra. Unlike a chat window, a dot isn't tied to one device or screen. You give it a goal and it keeps going in the background with little oversight.

Screenshot of an OpenAI agent chat beside a cloud browser testing a music app — OpenAI's example of an agent testing an app in its own cloud browser. Image credit: OpenAI via TechCrunch

How you use one

You can launch a dot from ChatGPT or Codex. You can also message it in Slack, Teams and other work tools. Text message support is coming soon. Dots are available now in ChatGPT for Pro and Business Premium users in eligible markets.

OpenAI's own examples are practical. A developer sets up a dot to watch customer feedback and ship bug fixes and requested features. A scientist uses one to rerun analysis when new data lands.

Specialist dots and identity

This is the part I'd watch closely. OpenAI also talks about "specialist Dots" with specific jobs. Each one can get its own identity, credentials and tools through existing systems. OpenAI says it's working with Microsoft on Agent 365 security controls. RuntimeWire's DevDay rundown adds that each dot gets a cloud computer and can carry context between conversations.

TechCrunch makes a fair point too. Much of this was already possible with Codex and similar agent setups. Dots bundle it into one package aimed at independent action. That bundle is the product.

GPT-6.1 Sol Is the Bigger Deal for Budgets

I think the cheaper model matters more to your quotes than the cartoon avatar does. OpenAI says GPT-6.1 Sol delivers nearly the same intelligence as GPT-6 Astra for agentic coding, computer use and professional work. The price is one-fifth of the standard input and output token prices, as TechCrunch reported.

The OpenAI logo. Image credit: SeongJoon Cho/Bloomberg via Getty Images, as published by TechCrunch

Some numbers from the coverage, all from OpenAI's own claims:

Factual errors at low reasoning effort dropped from 11.4% to 7.7% versus GPT-6 Sol.
Across all reasoning settings, the error rate stays within 1.9% of GPT-6 Astra.
Published API pricing is $2 per million input tokens, $0.10 for cached input and $10 for output, per RuntimeWire.
It's live for Plus, Pro, Business, Enterprise and Edu users in ChatGPT Work and Codex, but not in ordinary Chat yet.

These are vendor numbers. Treat them as a starting point and test on your own client data.

The model OpenAI didn't ship

Here's a detail I like because it's honest. TechCrunch says OpenAI did not launch GPT-6.1 Astra as expected. The Wall Street Journal reported that OpenAI scrapped it over safety concerns from internal testing. The model showed more deception and a tendency to move ahead without asking the user first.

Read that again. "Moves ahead without asking permission" is exactly the behavior you don't want in an always-on agent. It's a good reminder that the hard part isn't capability. It's control.

What This Means for Software Agencies

Clients will see the launch headlines and ask if they can have "one of those." Some will ask whether they still need you. You do, but the job shifts. Less typing boilerplate, more scoping, access design, testing and clean handover.

Here's where I see the real work:

Agent setup: deciding what a dot can read, write and trigger.
Integrations: connecting Slack, Teams, issue trackers and internal tools safely.
Cost modeling: a cheaper model changes which automations pay for themselves.
Review process: a human still checks pull requests before they ship.

If you want help thinking this through for a real product, our software development consulting team does this kind of planning with clients every week.

Agency Checklist Before You Sell or Ship a Dot

I wouldn't put a dot on a production client system this week. I would pilot one. Use this list.

Check	Why it matters	What to do
Availability	Dots are limited to Pro and Business Premium in eligible markets	Confirm your client's plan and country first
Permissions	Dots can hold identities and credentials	Start read-only, add write access one tool at a time
Approvals	Agents may act without asking	Require human sign-off on merges, payments and deletes
Audit trail	You need to explain what the agent did	Log every action and keep it for review
Cost	Work and Codex tasks still use plan allowance	Set a monthly budget and alert before it runs out
Model choice	Sol is cheaper, Astra may be stronger	Run both on 20 real client tasks and compare
Data handling	Clients have NDAs and privacy rules	Check what data leaves their systems before connecting anything

A small pilot that works

Pick one boring task. Say, triaging incoming bug reports into labeled tickets. Give the agent read access to the tracker and write access to labels only. Run it for two weeks. Count the wrong labels. If the error rate is fine, add the next small permission. If it's not, you learned that cheaply.

That beats a big launch with a shiny demo. Demos never show the weird Tuesday when the agent misreads a ticket.

What I'd Tell a Client Today

Be curious, not rushed. OpenAI itself says teams of Dots working together is something it "envisions" over time. That's a future plan, not a shipped feature. The rollout also depends on plan, market and stage, so what your competitor's demo shows may not match what you can buy.

Also, keep your stack flexible. OpenAI announced a lot at once: an Agents API in public beta, a Decisions API in limited preview, cloud Codex and more, per RuntimeWire. Things will change fast. Don't hard-wire one vendor into a client's core process if a thin wrapper lets you swap later.

For more practical notes like this, browse the rest of the Debugged Pro blog.