Meta Muse vs OpenAI Dots vs Grok Bot: CTO Comparison

Three of the biggest AI companies on earth shipped the same idea within three weeks of each other in September 2026: an agent that doesn’t wait for your next message. Meta shipped Muse on September 8. xAI had already shipped Grok Bot on August 11. OpenAI shipped dots on September 29. All three pitch themselves as “always-on” - an agent with its own computer, its own browser, and a standing mandate to keep working after you close the tab.

If you searched for “Clawbot” to find the third one: there’s no product by that name. The agent in question is xAI’s Grok Bot - a different thing from the base Grok chatbot and from xAI’s separate coding CLI, Grok Build. We’ll untangle all of that below, because getting the names right turns out to matter for understanding what each product is actually for.

This is a CTO-to-CTO comparison, not a feature tour. We pulled every claim here from vendor docs, vendor blogs, and (where vendors are silent) cross-checked independent reporting - and we say “not publicly documented” a lot, because that’s the honest answer for a lot of rows in the table below. If you’re deciding whether to pilot one of these inside your stack this quarter, this is the comparison to read first.

Get the names right first

• Muse is Meta’s product name; “Meta Muse” (as commonly searched) is accurate shorthand. It runs on a Meta-built model family called Muse Spark, not Llama.
• dots is OpenAI’s product name, styled lowercase on OpenAI’s own announcement page; most coverage capitalizes it as “Dots.” It runs on GPT-6 Astra. It is a ChatGPT feature, not a new API product - there is no dots API or SDK.
• Grok Bot is xAI’s product. It is distinct from Grok Build (xAI’s terminal coding-agent CLI) and from the everyday Grok chatbot. Grok Bot is the one that gets a persistent cloud computer; Grok Build is the one that lives in your terminal and writes code.

What each one actually is, from first principles

Muse: a personal agent for errands, wrapped in Meta’s app ecosystem

Muse is built for one job: take a task off a consumer’s or small business’s plate - book the tennis lesson, fill out the school permission slip, reorder the thing from the recipe reel you saved - without you babysitting a chat window. It runs asynchronously on a “Muse Secure VM” inside Meta’s cloud, continuing in the background after you close the app. The model underneath, Muse Spark, is a natively multimodal reasoning model with tiered modes - Instant, Thinking, and a “Contemplating” mode that runs multiple sub-agents in parallel for harder jobs.

Meta’s security story leans on that credential vault (the model never sees your passwords) and Stripe-issued single-use virtual cards for purchases, with explicit human approval required before money moves. A fully encrypted “Muse Confidential VM,” where even Meta can’t see the contents, has been announced but has no shipping date.

dots: an always-on delegate that lives where your team already works

OpenAI’s framing for dots is pointed: not a chatbot, a standing employee. You give a dot a goal, connect the apps it needs, set what it’s allowed to do unsupervised, and it works in the background on its own cloud computer - with its own browser - until it has something to show you or needs a decision. Because it inherits ChatGPT’s existing connector ecosystem, a dot can reach into 4,000+ already-integrated apps (Slack, Google Drive, Salesforce, and so on) on day one, and you can message it from ChatGPT, Slack, or Teams.

OpenAI’s own example use cases skew toward knowledge work: a developer dot that watches customer feedback and ships fixes, a research dot that reruns an analysis when new data lands. There is no dots-specific API - you don’t build with dots, you delegate to one inside ChatGPT.

Grok Bot: a computer-use teammate built for technical teams

Grok Bot’s whole pitch is that it gets its own persistent cloud computer - browser, filesystem, terminal, and a set of connectors - and stays logged in between sessions. Rather than one assistant, you get named “Bots” (think: a “Sales” Bot and an “Ops” Bot) that can run in parallel on one shared account-scoped VM and hand work to each other. Its most distinctive feature is “teach-a-task”: record yourself doing a workflow once, and Grok Bot turns the recording into a reusable skill, no API wiring required.

It’s deliberately positioned for people already living in developer tools - it’s bundled into Cursor plans as much as it’s sold on its own - and its sibling product, Grok Build, is a genuinely capable terminal coding agent (70.8% on SWE-bench Verified as of May 2026) that gives the broader “Grok agent family” real coding credibility, even though Grok Build and Grok Bot are separate products.

The 29-point framework

1. What the product is. Muse: a personal/SMB task agent. Dots: an always-on delegate for business and knowledge work inside ChatGPT. Grok Bot: a computer-use “AI teammate” aimed at technical teams.

2. Who built it. Meta Platforms (Muse, under Chief AI Officer Alexandr Wang); OpenAI (dots); xAI (Grok Bot).

3. The problem it’s designed to solve. Muse solves “I don’t want to do this errand myself.” Dots solves “I have a backlog of work already living inside my business apps that needs a delegate, not a chatbot.” Grok Bot solves “I need a teammate that can operate software - including code - the way a person would, continuously.”

4. Core architecture. All three share the same shape: client surface → vendor-hosted VM/cloud computer → model → connectors/browser/terminal. The differences are in isolation and surface area - Muse isolates per user, Dots per dot-instance (with shared memory on OpenAI’s side), Grok Bot shares one VM across all of an account’s Bots.

5. How the agent reasons and executes. Muse Spark uses tiered reasoning (Instant/Thinking/Contemplating) with explicit “thought compression” to cut inference cost. Dots runs on GPT-6 Astra with an agentic loop that works toward a goal and returns for approval. Grok Bot’s reasoning model isn’t publicly specified; its loop is explicitly “act on the computer, then report.”

6. Model support. Single-vendor, non-substitutable in all three cases: Muse→Muse Spark only, Dots→GPT-6 Astra only, Grok Bot→an undisclosed xAI model only. None lets you swap in a different foundation model.

7. Tool use. Muse and Grok Bot lean on a fixed connector catalog plus browser/computer-use for everything else; Dots adds the largest existing catalog (OpenAI’s 4,000+ app ecosystem).

8. Browser and computer-use capabilities. All three can drive a browser. Only Grok Bot documents full computer-use (terminal + filesystem + apps) as a core, marketed capability; Muse added macOS app control in September 2026; Dots’ “computer” is framed around its own cloud environment plus connectors rather than general desktop GUI control.

9. Memory and persistent context. All three retain memory across sessions (preferences, prior work, in Grok Bot’s case “skills” learned from a recording). None publishes a way for a user to inspect, export, or delete individual memories - this is a real gap across the board, not a Muse-only or Dots-only issue.

10. Multi-agent support. Muse Spark’s “Contemplating” mode parallelizes sub-agents internally; Dots explicitly markets “teams of dots”; Grok Bot runs multiple named Bots on one shared VM. Grok Bot is the only one that’s explicit about those agents sharing a security boundary rather than being isolated from each other.

11. Workflow automation. All three target recurring, multi-step work, not one-shot Q&A - that’s the entire category these products compete in.

12. MCP support. This is where the three genuinely diverge. Grok Bot documents MCP support directly, with the caveat that a local server must be tunneled or publicly reachable. OpenAI’s platform supports remote MCP servers and a Secure MCP Tunnel for private ones, but we could not confirm this is wired into dots specifically, as opposed to being a general Responses-API feature - see our MCP server vs webhook: when the server wins piece for what MCP buys you over a plain webhook integration, which is the right lens for judging this row. Muse’s consumer app has no documented MCP support at all; MCP shows up only in Meta’s separate developer-facing model API, which is a different product.

13. API support. Dots has none - it’s a ChatGPT feature, full stop. Muse has none for the consumer app, but a separate “Meta Model API” (Muse Spark 1.1, public preview, OpenAI/Anthropic-SDK-compatible) exists for developers building their own agents on the underlying model. Grok Bot has no standalone API either; it’s client-app-only.

14. Integrations. Dots wins on raw count (4,000+ apps inherited from ChatGPT). Grok Bot covers the core enterprise productivity stack (Gmail, Calendar, Drive, Outlook, Teams, SharePoint, Salesforce) plus MCP for the rest. Muse’s integration list skews consumer/commerce (Shopify, Stripe, Best Buy, Instacart) with a growing SMB set (Dropbox, Slack, QuickBooks, Klaviyo).

15. Local versus cloud execution. All three are cloud-only. None executes on your own hardware by default.

16. Self-hosting options. None. Zero, across all three. If that’s a hard requirement, skip ahead to the “none of the three is right” section below.

17. Enterprise and on-prem deployment. Grok Bot has the most defined enterprise motion (a named “Grok Bot for Enterprise” tier with access/network/audit controls). Dots has a Business Premium tier but no dots-specific enterprise security page we could find. Muse’s enterprise ambitions (“Meta Enterprise Platform,” “Muse API,” “Muse Code”) were announced but are thin on documentation as of this writing. On-prem is off the table for all three - there is no on-prem version of any of them.

18. Data privacy. Business/Enterprise workspace content is excluded from model training by default on OpenAI’s platform (dots inherits this general policy, not confirmed dots-specific). Meta says Muse “has no visibility into people’s passwords or payment methods” and trains on queries by default, with an opt-out and a promised (undated) workspace-privacy mode. xAI’s enterprise tier is described as adding access/network/audit controls; specific compliance certifications for Grok Bot appear only in secondary sources, not on xAI’s own enterprise page.

19. Security model. See table below - summarized, Muse relies on a credential vault + payment tokenization, Dots relies on layered permission surfaces with a non-trivial “pause doesn’t fully stop things” caveat, and Grok Bot relies on default-deny access plus explicit allow/deny/always-allow rules.

20. Human approval mechanisms. All three support approval gates before consequential actions (purchases for Muse, decision points for Dots, “hands control back to you” for Grok Bot). None of the three publishes a hard guarantee that a paused or denied action is instantly and completely reversible - see the trade-offs section below, this is a real operational risk, not a nitpick.

21. Observability and debugging. This is the weakest-documented row across all three. We found no vendor-published tracing/observability product for any of them. Third-party security analysis of Dots reports that cloud orchestration events don’t reach a customer’s own OpenTelemetry collector - treat that as a reported gap, not a confirmed OpenAI statement. If you’re used to instrumenting your own agents, read AI agent evals: what to measure before you ship before assuming any of these three will give you equivalent visibility - none will, today.

22. Developer experience. Grok Bot is the most “developer-shaped” of the three by distribution (bundled into Cursor), even though it has no API. Dots is the most “no-code” - you configure it inside ChatGPT. Muse is a consumer app; “developer experience” barely applies except via the separate Meta Model API track.

23. Extensibility. Grok Bot > Dots > Muse, in that order, based on MCP support, computer-use breadth, and the teach-a-task skill mechanism. Muse is the most closed of the three for a technical user who wants to extend it beyond Meta’s connector catalog.

24. Ease of setup. Muse is easiest (free app, no paid plan required to start). Dots requires an existing Pro/Business Premium ChatGPT subscription. Grok Bot requires a desktop app install plus a SuperGrok Heavy or Cursor subscription, plus MCP/connector configuration for non-trivial work - the most setup friction of the three.

25. Reliability for long-running tasks. Unproven for all three, not just one. Independent early-access reporting describes a dot claiming to be “running” after it had actually stopped; Grok Bot’s shared-VM design means one stuck computer can take down every Bot on an account at once; and Muse’s own stress testing reportedly saw only 33 of 120 parallel sub-agent runs succeed. Weigh vendor marketing accordingly.

26. Cost structure. Muse: free tier, $20/mo or $100/mo paid tiers. Dots: bundled into existing ChatGPT Pro ($100–$500/mo) or Business Premium ($125/user/mo), extra-dot pricing unpublished. Grok Bot: roughly $200/mo standalone, or bundled into SuperGrok Heavy ($300/mo)/Cursor plans, with a custom-quoted Enterprise tier and a cheaper self-serve Grok Business tier (~$30/seat/mo) reported by secondary sources.

27. Major limitations. Muse: blocked outright by at least one major retailer (Amazon), shaky shopping-task success rate in early reviews. Dots: no API, excluded markets (EEA/Switzerland/UK) on the Pro tier at launch, early reliability complaints. Grok Bot: no isolation between a single account’s Bots, local MCP needs tunneling, early-beta status acknowledged by xAI itself.

28. Best use cases. Muse: consumer/SMB errands and commerce. Dots: knowledge work inside an existing ChatGPT/Slack/Teams stack. Grok Bot: technical, computer-use-heavy operational work for teams already in the Cursor/xAI orbit.

29. Who should avoid it. Avoid Muse if you need enterprise governance or anything beyond consumer/SMB commerce workflows. Avoid Dots if you need an API, self-hosting, or a confirmed compliance certification today. Avoid Grok Bot if you need strict isolation between agents on the same account, or can’t tolerate early-beta reliability risk on something business-critical.

The comparison table

Every cell above is backed by a cited source or marked otherwise in this project’s fact-check file; where a vendor hasn’t published something, we wrote “not publicly documented” instead of guessing.

Architectural trade-offs that actually matter

Hosted vs. self-hosted. All three of these are hosted-only, full stop - which is itself the trade-off. You get zero infrastructure burden and zero patching, in exchange for zero control over where the model runs, zero ability to swap models, and a dependency on each vendor’s uptime and roadmap. If “the data never leaves infrastructure I control” is a real requirement - not a preference - none of these three products can satisfy it, no matter which one you pick. That’s a different category of tool, and it’s worth reading self-hosting n8n with Docker alongside our companion comparison of self-hostable agent platforms, OpenClaw vs Hermes Agent, before you assume a hosted agent is the only option.

Agent loops. All three follow the same basic shape - plan, act, observe, repeat, return for approval - but differ in where the loop runs and who can see inside it. Grok Bot’s loop is the most transparent to the end user (you watch it use a real screen); Dots’ loop is the most “fire and forget” by design; Muse’s loop is tuned for consumer latency, not auditability.

Context management. None of the three publishes context-window specifics for the agent’s working memory versus its long-term memory. Treat “it remembers things” and “it manages context well” as two different claims - only the first is documented for any of them. If what you actually need isn’t a full always-on agent but a single, bounded, repeated decision (route this, score that, flag this for review), a much narrower tool like JEV, TypeSafe’s “System One model” is worth a look before you reach for any of these three - it skips the agent loop and context problem entirely by design.

Memory architecture. This is the single biggest common gap across all three: persistent memory, yes; a user-facing way to inspect, correct, export, or delete what’s been remembered, no. For a CTO evaluating these for anything touching customer or employee data, that’s a compliance question you’ll have to answer with the vendor directly - it isn’t answered in public docs today.

Tool execution, permissions, and sandboxing. Grok Bot is the most explicit about isolation boundaries - and the most explicit that those boundaries don’t exist between a single account’s own Bots, only between different accounts. Dots’ permission model is the most granular on paper (separate surfaces for local computer, cloud computer, connected app, website session) but a third-party security review found that “pause” doesn’t actually stop delegated or recurring work, only the main task. Muse’s sandboxing story is the simplest to explain (credential vault, tokenized payments) but also the least documented at the infrastructure level.

Reliability. Covered above in point 25 - don’t take vendor demos as evidence of multi-week unattended reliability for any of these three. Early-access reporting on all three describes failure modes serious enough to change how you’d pilot one: silent “still running” false positives, shared-VM outages, and sub-agent failure rates far above what internal testing apparently expected.

Orchestration. Dots and Grok Bot both market explicit multi-agent orchestration (“teams of dots,” multiple named Bots); Muse’s orchestration is internal to the model (parallel sub-agents) rather than something you compose yourself. If you need to design a multi-agent system with your own topology, Dots and Grok Bot give you more surface to work with - Muse gives you none.

Human-in-the-loop. All three gate consequential actions behind approval. The meaningful difference is granularity: Grok Bot’s “Allow once / Deny / Always allow” plus “Auto Review” rules give you the most control over which actions need a human; Muse’s approval gate is effectively one gate (purchases); Dots sits in between, with custom rules that are explicitly described as instructional guidance the agent can still get wrong, not hard access controls.

Failure recovery. None of the three publishes a documented rollback or undo mechanism for actions already taken. “Pause” and “stop” affect future steps, not past ones, in all three cases as far as public documentation shows. Build your pilot assuming any action it completes is final unless you’ve separately verified otherwise.

Vendor lock-in. Complete, by model, in all three cases. There is no path to running Muse on anything but Muse Spark, Dots on anything but GPT-6 Astra, or Grok Bot on anything but xAI’s (undisclosed) model. This is the most important architectural fact in this entire comparison for a build-vs-buy decision, and it’s true of every option here - see build vs buy vs outsource for the broader framework on evaluating that kind of lock-in.

Observability. The weakest-documented dimension across the board, discussed above in point 21. If observability is a hard requirement for your use case, plan to build your own logging layer around whichever of these three you pilot - don’t expect the vendor to hand you one.

14 real-world scenarios: which one, and why

Which one should you choose?

Choose Muse if you or your team need a low-friction personal/errand agent, you’re a consumer or small business already inside Meta’s app ecosystem, and you don’t need enterprise governance, an API, or MCP.

Choose OpenAI Dots if your team already lives in ChatGPT plus Slack or Teams, you want the widest existing app connector reach with the least setup effort, and you can accept that there’s no API and no confirmed compliance certification yet.

Choose Grok Bot if your team is technical, you’re already in or open to the Cursor ecosystem, you need genuine computer-use (terminal, filesystem, browser) and MCP extensibility, and you can tolerate early-beta reliability risk and a shared-VM security model.

None of the three is right if you need self-hosting, on-prem deployment, model choice/portability, a documented compliance certification today, or proven reliability for business-critical long-running workflows. That’s a real, common set of requirements - and it’s exactly the gap self-hosted, open-source agent platforms are built to fill. If that’s your situation, read our companion comparison, OpenClaw vs Hermes Agent, before piloting any of the three products above.

Sources / Further Reading

• Meta, “Introducing Muse: The World’s First Personal AI Agent Built for Everyone” - primary announcement
• Wikipedia, “Muse (AI agent)” - consolidated, citation-backed overview including controversies
• TechCrunch, “Everything new coming to Meta’s AI agent Muse”
• TechCrunch, “Meta is expanding its AI agent Muse to small businesses”
• OpenAI, “Introducing dots” - primary announcement
• TechCrunch, “OpenAI launches Dots, its bubbly agentic avatar”
• OpenAI Developers, “MCP servers - tools & connectors” - platform-level MCP documentation
• General Analysis, “OpenAI Dots Security Controls” - independent analysis built on OpenAI’s own admin docs
• xAI, Grok Bot overview - primary documentation
• xAI, “Grok Bot for Enterprise” - primary announcement
• Wikipedia, “Grok Build” - coding-CLI sibling product, cited for the coding-ability comparison only
• Vellum, “Official Grok Bot Breakdown (2026)” - independent technical synthesis of xAI’s own documentation

Full fact-check notes, including every “not publicly documented” cell in the comparison table above, are maintained alongside this article’s research files.

Ready to Get Started?

Book a free 30-minute discovery call. We'll identify your biggest opportunities and show you exactly what AI automation can do for your business.

Book a Free Discovery Call

Suyash Raj Founder, Voxdonna AI and AiSewak. Writes here about n8n, AI agents, and voice automation.