Products

OpenAI's Dots: A Real Always-On Agent or Another Devin?

With 401 points and 306 comments on Hacker News, OpenAI's new always-on agent Dots is generating serious buzz. The comparison to Devin is hard to ignore.

Font size

OpenAI quietly dropped a new product called Dots (link) on the official blog last week, pitched as an "always-on agent" — an AI assistant that runs in the background rather than waiting for you to open a chat window. The post hit the Hacker News front page hard, pulling in 401 points and 306 comments (source). For HN, that's a real conversation.

Reading through the thread, excitement and skepticism are running at roughly equal volume. This piece covers three things: what Dots actually is, why HN is so divided on it, and how it stacks up against earlier attempts at the "always-on" agent idea.

What Dots Actually Is

Per the official blog, Dots is not another ChatGPT chat box. It's an always-on agent — you give it a goal, it runs in the background, and it pings you when there's something to report.

The shape of the interaction looks like this:

  • ChatGPT mode: user asks → model answers → done. The next interaction needs a human to kick it off.
  • Dots mode: user sets a goal → agent runs continuously in the background → proactively pushes results back → no human babysitting required.

In other words, ChatGPT is "you go find the AI," while Dots is "the AI comes to you."

The blog's example: you tell Dots to watch a GitHub repo, and whenever someone opens an issue with a specific label, it runs the tests, generates a patch, and pushes to a branch. Tasks like this usually mean either writing a wall of GitHub Actions YAML or a human staring at Slack. Theoretically, an AI could just sit there handling it for you.

Sounds great. The question is: how many people actually need an AI running 24/7?

In my own usage, most agent scenarios are "trigger-based" — fire it off when needed, close it when done. Always-on agents fit tasks that are asynchronous, long-running, and waiting on external events: monitoring, scheduled checks, data pipelines. Those needs exist in enterprise settings, but for a typical developer they're not exactly daily.

Why HN Is So Loud About This One

401 points and 306 comments is a big deal on HN. Here's how I sorted the recurring takes in the thread:

Positive camp (~40%):

  • "Finally, OpenAI is shipping a real agent product."
  • "The most exciting thing since ChatGPT itself."
  • "The next step after Operator."

Skeptical camp (~50%):

  • "Another Devin?" — by far the most common comment.
  • "People were yelling about always-on agents back in 2023."
  • "Where's the API, the open-source release, the actual benchmark numbers?"
  • "OpenAI launches are starting to feel like keynotes."

Meme camp (~10%):

  • The usual jokes, memes, and speculation about when Sam Altman is raising another $800M.

One detail stood out: "Devin" showed up more than 20 times in the comments. People are using Devin as the reference point, which tells you the category's collective memory is negative. Devin had this same launch energy last year, then the demo turned out to be staged, subscriptions cratered, and now nobody talks about it.

Another recurring word: "demo." A lot of people are asking whether Dots has any real running demo — something that shows it actually staying "on" for days and finishing real tasks — or whether it's another polished video.

"Always-On" Isn't New — OpenAI Didn't Invent the Term

A quick tour of the category:

  • Devin (early 2024): Cognition AI's "first AI software engineer," pitched as a 24/7 autonomous coder. Demo went viral, valuation hit $2B. Then it emerged the demo was pre-recorded, real performance fell well short, subscribers fled, and it's now basically quiet.
  • Replit Agent (late 2024): Spun out of the Replit IDE, capable of independently building web apps. Not 24/7 online, but can run tasks in the background. Still alive, though the positioning has drifted back toward "AI coding assistant."
  • AutoGPT (2023): The earliest product shouting the "autonomous agent" slogan — set its own goals, broke them into tasks, executed them. Mostly got memed into oblivion for running off the rails. Now it's basically just a GitHub star count.
  • Claude Computer Use (late 2024): Anthropic's release letting AI directly control a computer. Conversation-triggered rather than always-on, but it set the bar for agent GUI control.

The common thread across all of these: they all tried always-on or near-always-on shapes, and they all ended up pivoting toward "human-driven, AI-assisted" mode.

So what makes Dots think it'll work? I didn't find a clear answer in the blog. The confidence likely comes from OpenAI's existing product stack.

How Dots Might Actually Work Under the Hood

An always-on agent isn't a single-model problem — it's a whole system. Based on OpenAI's existing lineup, my guess is Dots stitches together four existing pieces:

1. O3 reasoning model — complex decisions, task decomposition, exception handling.
2. Operator browser agent — executing tasks that require web interaction.
3. Memory system — long-term memory across sessions and tasks.
4. Codex coding agent — code-specific subtasks.

Put together, the runtime might look something like this:

# Speculative Dots architecture (pseudocode)
class DotsAgent:
    def __init__(self):
        self.planner = O3()           # reasoning + planning
        self.executor = Operator()    # browser/tool execution
        self.memory = MemoryStore()   # long-term memory
        self.coder = Codex()          # code subtasks
        self.triggers = TriggerSystem() # background triggers

    async def run_forever(self, goal):
        while True:
            # Wait for an event (poll / webhook / schedule)
            event = await self.triggers.wait()
            # Decompose the task with O3
            plan = self.planner.decompose(goal, event)
            # Execute
            for step in plan:
                result = await self.executor.run(step)
                self.memory.record(step, result)
                if needs_code(step):
                    await self.coder.run(step)
            # Push results back
            self.notify(plan, result)

The hard part isn't the model — it's background reliability, cost control, error recovery, and the trust problem.

If an always-on agent runs off the rails overnight and burns $50 in API calls, the user is going to be upset when they see the bill. If it silently fails and the task never actually completes, they might not notice for a week. Until those two problems are solved, always-on stays a demo.

Editorial Take

My read: Dots is serious, but "always-on" is an overhyped need.

Where it's serious: OpenAI bundling Operator, Memory, and Codex into one unified product suggests internal buy-in on the category. This isn't another slide-deck launch.

Where it's overhyped: over the past two years, Devin, AutoGPT, and Claude Computer Use have each taken turns educating the market, and the result has been most people realizing they don't actually need an AI online 24/7 — they need agents that trigger reliably, cost little, and let humans step in anytime. Always-on is one valid trigger mode, not the only one.

Compared to the GPTs and ChatGPT plugins era — which flopped because developers lacked motivation and users lacked use cases — Dots is targeting "asynchronous long tasks," a narrower but more concrete need. The direction feels more right.

The biggest open question: whether OpenAI actually opens up Dots' core capabilities via API. If it's just a new feature inside ChatGPT, its ceiling is ChatGPT's user count. If there's an API, developers can build their own always-on workflows on top of it — and that's where the real upside lives.

I'm betting on the former. Happy to be proven wrong.

Source: https://openai.com/index/introducing-dots/