Dots vs Grok Bot vs Muse
Three agent products launched within seven weeks of each other. None of them is a model, none has a public API, and all three change what a request costs. Here is what each company actually publishes.
Side by side
| OpenAI Dots | Grok Bot | Meta Muse | |
|---|---|---|---|
| What it is | Always-on agents inside ChatGPT, each with a name, memory and its own cloud computer. | Named Bots that share one cloud computer, each with its own screen, driving apps like a person. | A personal agent in a dedicated secure VM with your data, watched by a separate permission agent. |
| What powers it | GPT-6 Astra | Not disclosed by xAI | Muse Spark |
| Where it runs | ChatGPT on web, desktop and mobile, plus Slack and Teams | macOS, Windows, Linux, iOS and Android | iOS, Android, muse.ai and WhatsApp |
| How you pay | One dot included with eligible paid plans. No published per-dot or per-token price. | Included with paid Cursor plans and Cursor Teams. Usage resets weekly; the allowance is not published. | Metered in Muse tokens: 500M a week on Power ($20/mo), 3B on Max ($100/mo). |
| Developer access | No Dots API. The model is on the API as gpt-6-astra. | No Grok Bot API. The Grok models are on the API. | No Muse agent API. Muse Spark models are on the Meta Model API. |
| Full analysis | Read the explainer | Read the explainer | Read the explainer |
The shared fact is the important one. All three are sold as products with a subscription, and none of them publishes what the agent work costs. That is a deliberate shift away from the per-token transparency the same companies offer developers.
Why an agent is not a chat model
The capability jump is easy to describe: these products can hold a goal over time, operate software, and come back with finished work instead of advice. The cost jump follows from the same four properties.
- The schedule. A chat model waits. An agent wakes up. Work that runs hourly runs whether or not it was needed that hour.
- Memory is input. Persistent context is re-sent on every run and grows over the agent's life. Caching lowers the rate, not the volume.
- Screens are images. Computer use turns a screen into tokens. A 1920 × 1080 screenshot is 2,448 input tokens on GPT-6 Astra, under OpenAI's published patch formula — more than twice a typical chat prompt.
- Thinking is output. Reasoning tokens bill at the output rate, which on every model here is the most expensive rate on the card.
The size of the difference
Artificial Analysis measures output tokens per task on its Intelligence Index, and the figures it reported give the only public like-for-like scale for agent work. Priced at each model's published output rate:
| Unit of work | Output tokens | Cost of that output | In chat answers |
|---|---|---|---|
| One chat turn on GPT-6 Astra | 500 | $0.04 | 1 |
| One task, GPT-6 Astra Max | 27,000 | $1.35 | 54× |
| One task, Grok 4.6 High | 36,000 | $0.22 | 72× |
| One task, Grok 4.7 xHigh | 81,000 | $0.49 | 162× |
The spread inside one vendor is as wide as the spread between vendors. Grok 4.7 at its highest reasoning setting produced about 2.3 times the output of Grok 4.6 on the same benchmark, at the same price per token. A reasoning dial is a cost dial.
Grok adds a second step that agents hit and chats do not: above 200,000 input tokens, every Grok 4.7 rate doubles, from $2.00 and $6.00 per million to $4.00 and $12.00. A long agent session carrying screenshots forward crosses that line; a chat turn never does.
And Meta's number says the same thing from the other direction. 500 million Muse tokens a week is roughly 333,333 chat exchanges a week, or about 1,984 an hour, every hour. Nobody chats that much. An allowance that size is only explicable as background work.
What the underlying models cost
This part is published, and it is where a real comparison is possible. Standard API rates per million tokens:
| Model | Input | Cached input | Output | One chat turn |
|---|---|---|---|---|
| GPT-6 Astra | $10.00 | $1.00 | $50.00 | $0.04 |
| Grok 4.7 | $2.00 | $0.50 | $6.00 | $0.0050 |
| Muse Spark 1.3 | $1.25 | $0.15 | $4.25 | $0.0034 |
Muse Spark 1.3 is the cheapest of the three by a wide margin, and Meta sells it cheaper still — $0.10 input and $0.20 output per million — on a contributor tier where your prompts and completions may train future models. GPT-6 Astra is the most expensive output on the list at $50.00 per million, which matters more for agents than for chat, because agents produce most of their tokens on the output side.
How to decide
- Judge the product on capability, not on token price. None of the three publishes one. Ask instead what it can reach: Dots has 4,000+ app connectors, Grok Bot has a real computer with your logins already on it, Muse has your phone and WhatsApp.
- Judge the cost on the model, with your own task. Measure one real task end to end, including reasoning output and screenshots, then multiply by the schedule. The schedule is the variable that makes agent spending unlike chat spending.
- Watch the step changes. Grok's 200K cliff and OpenAI's 272K long-context tier both double rates mid-session, and both are reached by agents far more often than by people typing.
- Read the data terms before the price. Meta's contributor discount is a priced trade on training data. A shared agent computer means a credential given to one Bot is reachable by all of them.
Questions people ask
What is the difference between Dots, Grok Bot and Muse?+
All three are agent products rather than models. Dots live inside ChatGPT and run on GPT-6 Astra. Grok Bot gives each Bot a screen on one shared cloud computer per account. Muse is a personal agent in its own secure VM, and is the only one of the three that meters itself publicly in tokens. None of them has a public API.
Which agent is cheapest?+
The question cannot be answered from published prices, because none of the three publishes a price for agent work itself. Dots and Grok Bot come with a subscription and no published allowance; Muse publishes a weekly token allowance but not what a Muse token counts. What can be compared is the API cost of the underlying models.
Why do agents use so many more tokens than a chat?+
Because the work happens without you. An agent runs on a schedule, re-sends its accumulated memory as input on every run, turns screens into image tokens when it uses a computer, and bills its reasoning as output. One measured agent task produces about 27,000 output tokens on GPT-6 Astra and about 81,000 on Grok 4.7 at its highest reasoning setting, against roughly 500 for a chat answer.
Can I use these agents through an API?+
No. Dots, Grok Bot and the Muse agent are all products, not model ids. The models behind them are available through normal APIs: gpt-6-astra, the Grok models, and Muse Spark.
How should I budget for an agent?+
Price the underlying model against the work, not the subscription. Measure one task end to end, including reasoning output and any screenshots, then multiply by how often the schedule fires. The schedule, not the model, is what makes agent spending different from chat spending.
Measure a real workload in the token calculator, see every model's rates on the comparison hub, or read the full explainers for Dots, Grok Bot and Muse.
Evidence ledger
Reviewed: 2 October 2026 · Product facts come from each company's own pages; every rate comes from the live model catalogue.
- OpenAI, Introducing Dots · OpenAI API pricing
- xAI, Grok Bot overview · xAI API pricing
- Meta, Introducing Muse · Meta subscriptions help
- Artificial Analysis Intelligence Index, output tokens per task, as reported by VentureBeat