The editorial argues Dots inverts the turn-based paradigm of every prior mainstream agent (ChatGPT agent mode, Claude computer use, Cursor, Devin) — the unit of interaction becomes a 'subscription to reality' rather than a session. This means agents stop being tools and become processes that need budgets, supervision, and health checks like any web service, which is a much bigger change than incremental model improvements.
Turn-based agents have a natural safety cap: you prompt, you approve, you close the tab, and the bill and damage stop when you stop asking. An always-on Dot can poll, reason, and act on its own schedule — meaning cost, error propagation, and unintended actions no longer have a human-shaped circuit breaker at the top of the loop.
Zapier, IFTTT, and workflow engines have done event-driven automation for a decade, so the trigger-action shape isn't new. What's new is an LLM with tool access deciding in the moment whether to act, ask, or wait — injecting probabilistic judgment into what were previously deterministic pipelines.
The submission hit 604 points in a day with 461 comments — respectable but notably not a blowout for an OpenAI launch. The editorial reads this muted-for-OpenAI reception as the developer audience being interested in the concept but wary of committing until questions about supervision, cost, and reliability are answered.
OpenAI introduced Dots, a new class of agent that runs continuously in the background rather than only when a user prompts it. The launch page frames Dots as "always-on agents" — persistent processes that watch inboxes, calendars, repos, and other data sources, and act on them without a human hitting return. The HN thread hit 604 points inside a day, which for an OpenAI launch is respectable but not blowout — a signal the audience is intrigued but reserving judgment.
The framing matters more than the product page suggests. Every mainstream agent shipped to date — ChatGPT's own agent mode, Claude's computer use, Cursor's background agents, Devin — has been fundamentally turn-based: you ask, it runs, it stops. Dots inverts that model. The unit of interaction is no longer a session; it's a subscription to reality. A Dot has a standing brief ("tell me when a customer replies about pricing", "draft a PR when a linter warning shows up", "summarize my Slack while I'm asleep") and it fires whenever the world matches its trigger.
OpenAI is not the first to try this shape — Zapier, IFTTT, and every workflow engine of the last decade did event-driven automation. The new part is what sits between the trigger and the action: an LLM with tool access and enough judgment to decide, in the moment, whether to act, ask, or wait.
The reason turn-based agents feel safer is that a human is always the top of the loop. You prompt, you approve, you close the tab. Once you remove that human trigger, an agent stops being a tool and starts being a process — and processes need supervision, budgets, and health checks the same way a web service does. That's a much bigger change than "the model got smarter."
Start with cost. A turn-based agent bills you per invocation, which caps blast radius naturally: if it goes weird, the bill and the damage stop when you stop asking. An always-on Dot can, in principle, poll and reason and act on its own schedule. Even if each individual call is cheap, the idle-hour math is different: a fleet of ten Dots checking their triggers every minute is 14,400 wake-ups a day, most of which do nothing. Whether that's $2 or $200 depends entirely on how OpenAI meters it, and the launch materials are (as usual) short on pricing specifics. Expect the community to figure out the actual per-Dot-day economics within a week.
Then there's permissioning. A ChatGPT session inherits your intent for the next few minutes. A Dot inherits your intent for the next few months, and you'll almost certainly forget what you told it. The interesting bug class isn't "the agent hallucinated a tool call" — it's "the agent did exactly what I asked it to do six weeks ago, and I no longer want that." The lifecycle problem is real. Whoever wins the always-on space will need first-class primitives for expiring, pausing, auditing, and diffing what a persistent agent is currently authorized to do — not just what it did in its last run.
Community reaction on HN split predictably. The pragmatists asked about rate limits, sandboxing, and whether Dots can call other Dots (the answer to which determines whether this is an interesting product or an accidental botnet). The skeptics pointed out that "always-on agent" is what every AI startup has been pitching investors since 2023 and that shipping the pattern under an OpenAI brand doesn't validate the pattern; it just lowers the activation cost for everyone else to build on top. Both are right. The launch is less a technical breakthrough and more a distribution event: once OpenAI normalizes the always-on shape, every SaaS that wants to sell an "AI teammate" will feel pressure to ship one, and the operational hard parts get externalized to whoever integrates.
The comparison worth making is to cron. Cron is a durable, boring primitive that quietly runs half the internet. If Dots ends up being "cron with judgment" — a scheduler where each fire gets a model in the loop — that's actually useful and worth building against. If it ends up being "an agent that hallucinates on your calendar every 90 seconds until you delete it," that's the failure mode, and it will be very visible very quickly.
If you're already building agents, the near-term implication is that your competitive story just got harder. A homegrown agent that only runs when someone opens a dashboard is about to feel dated next to a Dot that pinged the user at 7am with the answer. Consider what your product would look like if it had a persistent, low-friction listener attached — for many B2B tools, that's a natural extension, and building it yourself on top of Dots will be cheaper than shipping your own scheduler, memory, and tool-execution loop.
If you're operating agents in production, the ops surface just widened. You now need per-Dot observability (what did it do, how much did it cost, what did it almost do), a global kill switch that a non-engineer can hit, and budget caps that fail closed rather than open. Treat every always-on agent as a service with an on-call rotation, not as a chat window that happens to run in the background. The teams that skip this step will discover their first incident is a Dot spending $400 in a loop or auto-replying to a customer with the wrong tone at midnight.
If you're evaluating whether to adopt Dots at all, the honest answer is: wait two weeks. The launch is fresh, the pricing model isn't fully clear, and the failure modes haven't hit the timeline yet. The first wave of interesting posts will not be from OpenAI — they'll be from the developer who left a Dot running over a weekend and came back to something instructive.
The agents-that-live-somewhere pattern is going to be the dominant shape of the next 18 months, and Dots is OpenAI's opening move rather than the finished product. The winners will be whoever solves the boring parts — cheap idle, tight permission scopes, clean lifecycle controls, and observability a human can actually read — because the model quality is table stakes now. If OpenAI ships those primitives well, Dots eats a real category. If it doesn't, someone whose entire product is "cron for LLMs" will, and OpenAI's launch will have done them the favor of educating the market.
Top 10 dev stories every morning at 8am UTC. AI-curated. Retro terminal HTML email.