Tool Reviews

Daily AI reviews OpenAI Dots versus Meta Muse and everything you need to know about the next wave of AI agents.

OpenAI Dots and Meta Muse compare as persistent AI agents, separating models from agent stacks, execution loops, memory, sandboxes, and security.

Daily AI reviews OpenAI Dots versus Meta Muse and everything you need to know about the next wave of AI agents.

Key Takeaways

  • In September 2026, Meta Muse and OpenAI Dots represented a shift from short-lived chatbots to persistent, always-on AI agents that run on cloud computers, remember across sessions, and execute background tasks toward multi-day goals.
  • The underlying language model is not the agent itself; a full agent combines the model with goal tracking, task planning, persistent memory, sandboxed execution, scheduling, security approval, and external API connectors.
  • These agents operate as continuous state machines: they ingest standing objectives, load context, plan steps, run tools in isolated environments, checkpoint progress, pass policy gates, and resume after failures or scheduled events.
  • Meta Muse emphasizes a hardened Linux security architecture with dedicated per-user VMs, the Hatch harness, and Sentinel network controls, making the comparison with Dots less about raw models and more about two philosophies of building secure, persistent cloud agent runtimes.

For anyone who has used a chatbot, the rhythm is familiar: type a prompt, watch tokens stream for a few seconds, then close the tab. The model forgets everything the moment it stops. That pattern changed in September 2026, when Meta and OpenAI each launched a persistent agent that runs on its own cloud computer, executes background tasks, and works toward multi-day goals without being prompted.

Daily AI reviews OpenAI Dots versus Meta Muse and everything you need to know about the next wave of AI agents.

Meta introduced Muse on September 8, 2026. OpenAI followed with Dots on September 29, 2026. Both are marketed as "always-on autonomous agents," and both mark a shift from three-second request-response chat to scheduled background runtimes. This article explains how each system is built, where their architectures diverge, and what early failures reveal about the limits of the technology.

The model is not the agent

The most common misunderstanding about these products is that the underlying language model is the agent. It is not.

Dots runs on GPT-6 Astra. Muse runs on the Muse Spark family, specifically Muse Spark 1.3. Both are strong reasoning engines capable of planning, tool selection, zero-shot command-line skill use, and code synthesis. But a standalone LLM cannot make an HTTP request, write a file to disk, or wake itself up in twenty minutes to check whether a batch job finished. When its forward pass ends, its internal activations disappear.

An agent is the distributed software system built around that model. The stack typically includes:

  • User goal layer: natural-language instructions, standing constraints, and ongoing objectives.
  • Task planner and orchestrator: breaks vague goals into directed acyclic graphs of subtasks.
  • Cognitive core (LLM): evaluates state, reasons about obstacles, and picks tools.
  • Persistent memory store: scratchpads, run histories, and user preferences that survive across sessions.
  • Execution sandboxes: isolated cloud VMs or containers with access to bash, browsers, code interpreters, and filesystem APIs.
  • Scheduler and event bus: triggers work via cron timers, webhooks, or external events.
  • Security and approval gateway: out-of-band policy engines such as Sentinel or Auto-Review that enforce permissions and human approval.
  • External connectors: authenticated links to Gmail, GitHub, Slack, databases, and third-party APIs.

Comparing Dots and Muse means comparing two philosophies of building a secure, persistent cloud agent runtime, not just two models.

How the execution loop works

A concrete example makes the engineering tangible. Suppose a user gives the agent this standing objective:

"Every weekday at 6:00 AM, scan the SEC EDGAR database for Form 4 insider purchases above $500,000 in the semiconductor sector. Cross-reference the filings with recent quarterly earnings reports, draft an executive summary, save it to my research folder, and notify me before market open."

Daily AI reviews OpenAI Dots versus Meta Muse and everything you need to know about the next wave of AI agents.

A traditional chatbot would hand back a Python script to run locally. An always-on agent runs a continuous state machine instead:

  1. Goal ingestion: the orchestrator parses the request and writes a durable state entry with a cron trigger for 06:00 UTC, Monday through Friday.
  2. Context hydration: when the timer fires, the runtime loads prior filings already processed, formatting preferences, and authorized credentials.
  3. Planning: the model builds a plan—query the SEC EDGAR API, parse XML tables, filter by SIC code and transaction value, search financial news for context, write the markdown report.
  4. Sandboxed execution: the agent runs Python inside an isolated container. If the EDGAR API returns a 429 rate-limit error, it catches the exception, backs off exponentially, and retries.
  5. Observation and checkpointing: after each tool call, it reads the output and updates persistent state. If the container crashes or the host reboots, work resumes from the last checkpoint.
  6. Policy validation and delivery: the report is saved to the workspace, and the outgoing notification passes through a security gate before sending.
  7. Suspension: telemetry is written to the episodic log, and the thread sleeps until the next scheduled event or webhook.

Running this reliably for millions of users without runaway compute costs or dangerous hallucinated actions is one of the harder engineering problems of the decade.

Meta Muse: a Linux fortress

Meta published unusually detailed architecture documentation alongside Muse, which focuses on personal tasks, scheduling, everyday commerce, and integration with WhatsApp and other Meta apps. Its guiding assumption is blunt: the language model will eventually execute untrusted or malicious code, or encounter adversarial data. Rather than relying on alignment alone, Meta built a hardened Linux environment around the model.

Dedicated per-user secure VMs. Every Muse user gets a dedicated Linux virtual machine with no multi-tenant memory sharing at the runtime level. A runaway agent or fork bomb cannot affect another user's environment. The VM has enough CPU, memory, and disk to compile software, build custom command-line skills, run concurrent subagents, and maintain long-running cron jobs.

The Hatch agent harness. Inside the VM, the agent does not run as privileged root. It runs in a lightweight cell managed by systemd-nspawn, internally called the Hatch harness. Root inside the container maps to an unprivileged host UID. Critical kernel capabilities such as CAP_SYS_ADMIN, CAP_SYS_PTRACE, and CAP_NET_ADMIN are stripped before initialization. Hatch communicates with outside services only over Unix domain sockets with peer credentials and explicit access control lists, so no open network ports exist inside the VM.

Sentinel network warden. A persistent agent needs internet access, but unrestricted outbound traffic invites data exfiltration. Meta's Sentinel is an out-of-band, host-side monitor that acts as the sole permission authority for connector actions and outbound traffic. Requests pass through a forward proxy governed by eBPF probes and user namespaces. Sentinel inspects traffic at Layer 4 and Layer 7—hostname, resolved IP, port, protocol, HTTP verb, URL path, and decoded payload. It enforces two boundaries: blocking server-side request forgery so public-looking domains cannot resolve to private internal IPs or cloud metadata endpoints such as 169.254.169.254, and tracking "tainted" egress that originates from untrusted web pages.

Surrogate credentials. Muse keeps OAuth refresh tokens and API secrets in an encrypted keystore outside the container, managed by a daemon called hatch-authd. The model only sees opaque, short-lived surrogate tokens. A privileged connector worker intercepts authorized calls, verifies capability permissions, and swaps the surrogate for the real signature at the network boundary. Even if a prompt injection tricks the agent into printing its environment variables, it holds nothing of value.

Daily AI reviews OpenAI Dots versus Meta Muse and everything you need to know about the next wave of AI agents.

Accessibility-tree browsing. Instead of direct DOM manipulation, Muse's browser subagent interacts through the browser's accessibility tree via a Chrome DevTools Protocol broker. It cannot execute arbitrary JavaScript in the page context, cannot run script verbs or inspect DevTools consoles, and pauses automatically when the user takes over the browser or credentials are being filled. Independent classifiers scan page content, images, downloaded files, and high-risk form submissions for injection payloads.

Isolated payments. If payment details already exist on a merchant site, Muse detects checkout and halts for explicit human approval. For new merchants, Muse integrates with Stripe Link, with Shop Pay planned, rather than exposing stored card numbers to the agent runtime.

OpenAI Dots: the other philosophy

Dots arrived three weeks after Muse, powered by GPT-6 Astra and positioned as OpenAI's answer to the same problem: a persistent cloud runtime that acts on a user's behalf. Where Meta's documentation emphasizes a fortress model—assume the model is hostile and contain it—OpenAI's approach centers on a different balance between capability and control. Both companies are converging on the same core components: sandboxed execution, persistent memory, schedulers, and approval gates. The differences lie in how much freedom the agent gets inside the sandbox and how much of the security burden falls on the model versus the surrounding infrastructure.

What the early failures show

The first generation of always-on agents has already produced real-world incidents worth studying. The pattern is consistent: failures rarely come from the model being "dumb." They come from the gap between a plan and its execution—rate limits that trigger retry storms, credentials that leak into logs, web pages that inject instructions the agent follows, and scheduled jobs that compound errors across days because nothing stops them.

This is why the architectural details matter more than benchmark scores. A model that reasons well but runs without checkpointing, egress filtering, or approval gates will eventually cause damage at scale. A slightly weaker model inside a well-designed harness will not.

What this means for readers

If you are evaluating these tools, the practical questions are not about which model is smarter. They are about what the agent can touch, what it can spend, who approves irreversible actions, and how you can audit what it did while you slept. Both Muse and Dots are designed for multi-day goals, which means mistakes can persist and compound. Start with tasks that are reversible, keep approval gates on anything involving money or external communication, and treat the agent's memory as something to review, not trust blindly.

The shift from chatbot to background runtime is the real story of September 2026. The model is only one part of it.

Comments (0)

  1. No comments yet. Be the first to share what worked for you.

Leave a comment

Comments are reviewed before they appear. Your email address is not published.