Personal AI Agents Compared: Grok Bot, OpenAI Dots, Meta Muse and Claude Duet, and Which One Can Read Twitter (X)

This is the four-way comparison of the personal AI agents that launched in 2026, written for people who build with them: what each one costs, where it runs, how it connects to your tools, and whether it can read X. It is not a setup guide for one agent. If you run the open-source Hermes Agent, our Hermes Agent and Twitter (X) guide covers that single agent and its xurl skill in depth; this page covers the four hosted products from xAI, OpenAI, Meta and Anthropic and treats X data as the test case for how open each one is.
Every fact about a product below comes from the vendor's own page, read for this article: docs.x.ai and Cursor's Grok Bot help for Grok Bot, learn.chatgpt.com for dots, about.fb.com and Meta's help center for Muse, claude.com and support.claude.com for Duet. Where a vendor page did not say something (Meta never mentions MCP, OpenAI's dots docs never mention X), the table says so instead of filling the gap from posts or press. We could not run all four agents ourselves (dots needs a Pro plan, Duet is a US waitlist, Muse is in limited testing), so the connector column reports what the docs allow, and the MCP server side was tested live.
We also measured how X reacted. We searched X for each product name and read the official launch posts: 1,248 posts, collected in 2026. The short version: the dots conversation is a comparison conversation, and almost nobody is yet asking these agents to read X, which is exactly the gap a bring-your-own-data connector fills.
What counts as a personal AI agent in 2026
The four products share a definition that their vendors spell out in nearly the same words. OpenAI calls a dot "an always-on agent that keeps work moving across your tools and projects" with "its own computer and browser" in the cloud. Meta says Muse "runs on Muse Secure VM, a dedicated secure computer with its own browser." Anthropic says Claude Duet "has a virtual machine with its own browser, so it doesn't require your laptop or phone to be on." xAI's docs say each Grok Bot "works on a persistent cloud computer with a browser, filesystem, and terminal."
Always on. Each keeps working after you close the app and comes back with results or questions. Duet checks your connected accounts "every few hours, because checking nonstop would use up your plan's limits much faster"; a dot "can decide when to pause and wake up to continue work."
Asks before it acts. Duet shows exactly what it is about to do before it "sends a message, makes a payment, signs a document, or deletes anything." Muse checks "before sensitive actions like sending an email or making a purchase." Dots run every account-affecting action through automatic review that decides whether the dot can proceed, needs approval or must hand the step to you. Grok Bot "comes back when something needs your approval."
Connected to your apps. All four reach email, calendar and chat tools through connectors or plugins, and fall back to their cloud browser for sites without one. This is where they differ most, and it decides what you can plug in yourself.
That last point is the builder's question. A personal agent is only as useful as the data it can reach, and X (Twitter) is a good test: it is public, fast-moving, and important to many of the people who would run an agent, yet three of the four products have no built-in path to it.
Grok Bot vs OpenAI dots vs Meta Muse vs Claude Duet: the comparison table
Prices, plans and platforms as each vendor's own page states them. "Not stated" means we looked and the page does not say.
Connectors, MCP and X access are what matter for building on top of them:
Two caveats. First, model choice: dots run on GPT-6 Astra, Muse on Muse Spark and Duet on Claude Opus 5.5 with no model picker during the preview; the Grok Bot overview does not name a model. Second, usage: conversations with a dot "don't count toward your ChatGPT usage limits", while Duet's background checks do count against Pro and Max limits, Muse meters Muse tokens per week, and Grok Bot draws on a weekly pool.
Which personal AI agent can read X (Twitter)?
Grok Bot: yes, built in. xAI's docs say Bots "can search and read what's public on X without you connecting an X account": search posts, open a post from its link, read an account's posts and mentions, see who quoted or reposted a post, count recent posts on a topic, check trends. That access "is read-only and doesn't sign in as you." For DMs, bookmarks, your home timeline or who liked your posts you add the X plugin, and Cursor's Grok Bot help says "the X plugin needs X API credits on your X developer account." Our Grok Bot page walks through what those credits cost per task.
OpenAI dots: no native X access. The dots docs describe plugins (Gmail, Google Drive and GitHub are the examples) and a cloud browser that can sign in to websites. X is not mentioned. A dot could open x.com in its browser after you sign in, but that is your account doing browser work at agent speed, which is exactly what a data API avoids.
Meta Muse: no native X access. Facebook, Instagram and Threads connect automatically through Accounts Center; X is not among the connectors Meta lists. Muse can build a custom connector for a service that lacks one, and Meta says it "doesn't review custom connectors or how they use your information."
Claude Duet: no native X access. Duet uses "the connectors you've connected in Claude" (Gmail, Calendar, Drive, Slack, QuickBooks, HubSpot, Docusign, Calendly are Anthropic's examples), and "for sites that don't have a connector, Claude Duet uses its own browser in the cloud." There is no X connector in that list.
So the practical split is one agent with first-party X reads and three that need a connector. For the three, a remote MCP server is the cleanest path, because it plugs into the connector system they already have and keeps your X account out of the loop: reads need no X account at all.

Bring your own X data: the twitterapi.io MCP server in each agent
TwitterAPI.io runs a remote MCP server at https://mcp.twitterapi.io/mcp. We probed it for this article: initialize answers over plain HTTPS, tools/list returns 12 read tools (search_tweets, get_user_info, get_user_about, get_user_followers, get_user_followings, get_user_last_tweets, get_user_mentions, get_tweets_by_ids, get_tweet_replies, get_tweet_quotes, get_tweet_retweeters, get_trends), and a tool call without credentials returns 401 with a WWW-Authenticate header pointing at its OAuth metadata (scope twitter.read). The server's own instructions also accept "your twitterapi.io API key as the Bearer token", so a connector that only supports a fixed header works too.
Claude Duet. Duet inherits the connectors on your Claude account. In Claude, Customize, Connectors, "+ Add", "Add custom connector", paste the URL, then either sign in (OAuth) or, under Request headers, add Authorization: Bearer <your key>. Anthropic's help says custom connectors using remote MCP are available on Free, Pro, Max, Team and Enterprise, with Free limited to one. Because Duet is a waitlist preview we could not confirm a custom connector inside Duet itself; the docs say Duet works with the connectors you have connected in Claude.
OpenAI dots. OpenAI's plugin docs: go to ChatGPT Plugins, select the plus button, then Add custom MCP server, enter the URL "including the /mcp path", configure authentication and "Create as a plugin." The server must be reachable on public HTTPS (or through OpenAI's Secure MCP Tunnel). A dot "can use supported plugins installed and enabled for your account"; "account and workspace policies apply" to custom servers, so check your plan's plugin settings. Our ChatGPT MCP guide covers the OAuth handshake ChatGPT expects.
Meta Muse. Meta documents no MCP support. The route Meta does document is to ask Muse to create a custom connector, giving it the API information it asks for; Muse stores credentials in its Secure Credentials Store. Hand it the REST endpoints from docs.twitterapi.io and an API key, and keep the key's spending limited: Meta does not review custom connectors.
Grok Bot. You rarely need it for public reads, since Grok Bot already searches X. The cases where you would: bulk pulls (hundreds of accounts, follower lists), exact historical windows, or data you want as files. A Bot has a terminal on its cloud computer, so the Python script below runs there unchanged; Grok's own connectors page documents custom MCP connectors for Grok, which the Grok Bot docs we read do not mention.
# What the agent's connector will see. Run these before you add the server anywhere.
# 1. Handshake: the server answers initialize over plain HTTPS
curl -s https://mcp.twitterapi.io/mcp \
-H 'content-type: application/json' \
-H 'accept: application/json, text/event-stream' \
-d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18","capabilities":{},"clientInfo":{"name":"check","version":"1"}}}'
# 2. Tool list (12 tools: search_tweets, get_user_info, get_user_last_tweets, get_user_mentions, ...)
curl -s https://mcp.twitterapi.io/mcp \
-H 'content-type: application/json' \
-H 'accept: application/json, text/event-stream' \
-d '{"jsonrpc":"2.0","id":2,"method":"tools/list"}'
# 3. A tool call with your key as the Bearer token (the same value goes in a
# connector's "request header" field: Authorization: Bearer <key>)
curl -s https://mcp.twitterapi.io/mcp \
-H 'content-type: application/json' \
-H 'accept: application/json, text/event-stream' \
-H "Authorization: Bearer $TWITTERAPI_IO_API_KEY" \
-d '{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"get_user_last_tweets","arguments":{"userName":"claudeai"}}}'
What X data costs your agent: twitterapi.io vs the X API rate card
Whichever agent you use, the agent's subscription does not pay for X data. Grok Bot's X plugin runs on X API credits on your own developer account; the other three need a connector you supply. The two prices to compare:
X's figures come from its pay-per-usage rate card at docs.x.com/x-api/getting-started/pricing, which also caps pay-per-usage at 3 million post reads per monthly billing cycle (Enterprise above that) and offers $20 in credits on a first eligible card plus a match of up to $50. Per 1,000 tweets the ratio is $5 against $0.15, about 33x.
On twitterapi.io, $1 is 100,000 credits and purchased credits never expire. New accounts that pass the automatic bot check get up to $1 of free credits (at most 100,000 credits, no card, one per person or network, expiring after 31 days). Rate limits start at 0.2 requests per second before the first payment and rise to 20 once paid, which is plenty for an agent that checks in every few hours. Reads need no X account. Subscriptions from $29 a month exist for steady volume; see the pricing page rather than per-request math.
An agent's habits make the floor price matter. Duet checks your accounts every few hours; a dot "can decide when to pause and wake up"; a Grok Bot routine runs on a schedule. A check that finds nothing new costs $0.00015, so polling one search every 5 minutes for a month is $1.30 and every 60 seconds is $6.48.
How X reacted to the four launches
We searched X for each product name (retweets excluded) and pulled the official launch posts. Each vendor's launch landed big: OpenAI's "Introducing dots, powered by GPT-6 Astra" post reached 14.8 million views and 38,102 likes; the @claudeai post opening the Claude Duet research preview drew 54,551 likes and 9.6 million views; Mark Zuckerberg's "Introducing Muse" post had 8.7 million views and the @Muse account's own launch post 8.0 million.
dots is discussed as a comparison. 58.6% of posts about OpenAI dots named Grok Bot, Muse or Duet (38.4% named Duet, 36.7% Grok Bot, 35.7% Muse). That matches the search data behind this page: queries like "dots vs muse" went from nothing to measurable volume in a month.
Grok Bot is a different kind of noise. The phrase "Grok Bot" ran at 456 posts an hour, but it also catches people calling the @grok reply account a bot, and the @bot account itself wrote 31.7% of the raw Latest sample ("On it. Sending that over to your Grok Bot now"), which we excluded. Grok Bot posts almost never named a rival (3.0%).
Nobody is asking for X data yet. Only 1.0% of dots posts, 0.7% of Muse posts and 1.4% of Duet posts mentioned X, Twitter, tweets or timelines, against 7.6% for Grok Bot, the one with X built in. Price came up in 13% to 16% of posts for all four, and connectors in 5% to 9%.
Muse has a Japanese audience. 23.6% of Muse posts were in Japanese, against 15.2% for dots and 8.5% for Duet.

Which personal AI agent should a builder pick?
You live on X and want X reads with zero setup: Grok Bot. It is the only one that reads public X out of the box, from $30 a month on The X Subscription Premium or with a paid Cursor plan you may already have. Add the X plugin only if you need DMs, bookmarks or your home timeline, and budget X API credits for it.
You want the most open connector system: Claude Duet or dots. Both accept a remote MCP server URL, so anything with an MCP server (your own internal tools, X data, a database) becomes a tool the agent can call. Duet is cheaper to reach (Claude Pro at $20 a month) but US-only and waitlisted; dots needs ChatGPT Pro at $100 a month or more and is not offered on Pro in the EEA, UK or Switzerland.
You want free and consumer reach: Meta Muse. Muse is the only one with a free tier and it lives in WhatsApp as well as its own app. Its custom connectors are built by Muse from an API description rather than a standard MCP URL, so expect more back-and-forth when you wire in your own data.
You want one agent across many people: check team plans first. Duet is not on Team or Enterprise yet; dots are off by default on Enterprise until an admin turns them on; Grok Bot has team seats on The X Subscription and Cursor Teams; Meta's pages we read describe Muse plans for individuals only.
Whichever you pick, keep the expensive or account-bound steps in your own code. A short script that pulls X data with an API key, writes a JSON file and lets the agent read it is easy to audit, costs cents, and does not hand your X login to an agent's cloud browser.
A script any of the four agents can run
The code at the end of this page is a smaller version of the study below: for each product name it pulls the latest posts with /twitter/tweet/advanced_search, follows next_cursor while has_next_page is true, and reports posts per hour, topic shares and the most-liked post. It reads only the documented fields (tweets[], createdAt, text, likeCount, viewCount, url).
Where to run it. On your machine, then hand the JSON to any agent. On Grok Bot, save it to /workspace on the Bot's computer and ask the Bot to run it on a routine. On dots, Muse or Duet, their cloud computers can run it if you give them the file and the key, but the MCP route above is tidier because the key stays in the connector settings.
What it costs. Five pages for one name is at most 100 tweets, which is $0.015. The script prints its own estimate from the number of tweets returned.
How we collected this
Question. How did X react to the four personal agents: how fast posts naming each one arrive, how engaged the top posts are, what share mention price, connectors, X data or another of the four, and how far the official launch posts reached.
Queries and accounts. "Grok Bot", ("OpenAI dots" OR "ChatGPT dots" OR "OpenAI dot" OR "ChatGPT dot"), ("Meta Muse" OR "Muse agent" OR "Muse by Meta") and "Claude Duet", each with -filter:retweets, through /twitter/tweet/advanced_search: up to 12 Latest pages and 4 Top pages per product. Launch posts from organization and public-figure accounts: @claudeai, @AnthropicAI, @OpenAI, @Meta (with reposts of @Muse and @finkd) and @SpaceXSI.
Sample and window. 1,248 posts (960 Latest, 288 Top), collected in 2026. The Latest window differs by product because pace differs: about 22 minutes for Grok Bot, 7 hours for Duet, 13 hours for Muse and 26 hours for dots. Vendor accounts (@bot, @grok, @OpenAI, @claudeai and similar) were excluded from the topic shares. 73 requests, 1,332 tweets returned, about $0.20 in credits.
Method. Topic shares are case-insensitive keyword matches on post text after removing leading reply mentions, over the union of Latest and Top posts. Posts per hour divides the Latest sample by the hours it spans. The analysis script and aggregates are published with the page.
What it cannot show. A keyword match is not sentiment, and short Latest windows are a snapshot of one moment, not a daily average. "Grok Bot" is also a casual phrase for the @grok reply account, so its pace overstates talk about the product. Search coverage of non-English posts may differ by language.
Privacy. Aggregates only. Raw search pages were kept out of the repository because their authors are private individuals; only organization and public-figure launch posts are named.
"""agent_x_pulse.py - the X data a personal AI agent cannot get on its own.
Run it on your laptop, or on the agent's cloud computer (Grok Bot has a terminal;
dots, Muse and Duet can run scripts in their cloud computers) and ask the agent to read the JSON.
pip install requests
export TWITTERAPI_IO_API_KEY=... # from twitterapi.io/dashboard
python3 agent_x_pulse.py "Claude Duet" "OpenAI dots" --pages 5 > pulse.json
"""
import argparse, json, os, re, sys, time
from datetime import datetime
import requests
BASE = "https://api.twitterapi.io"
HEADERS = {"X-API-Key": os.environ["TWITTERAPI_IO_API_KEY"]}
TOPICS = {
"price_or_plan": r"\$\s?\d|pric|\bcost|per month|subscri|\bplans?\b",
"connectors_mcp": r"connector|\bmcp\b|plug-?ins?\b|integrat",
"x_data": r"\btwitter\b|\btweets?\b|x api|timeline",
}
def search(query, pages):
"""Newest-first posts that match an X advanced-search query (20 per page)."""
params = {"query": f'"{query}" -filter:retweets', "queryType": "Latest"}
out = []
for _ in range(pages):
r = requests.get(f"{BASE}/twitter/tweet/advanced_search", headers=HEADERS, params=params, timeout=30)
if r.status_code == 429: # rate limited: wait, retry the same page
time.sleep(5)
continue
r.raise_for_status()
body = r.json()
out.extend(body.get("tweets") or [])
if not body.get("has_next_page") or not body.get("next_cursor"):
break
params["cursor"] = body["next_cursor"]
return out
def parse(ts):
return datetime.strptime(ts, "%a %b %d %H:%M:%S %z %Y")
def pulse(name, pages):
posts = search(name, pages)
if not posts:
return {"product": name, "posts": 0}
times = [parse(t["createdAt"]) for t in posts]
hours = max((max(times) - min(times)).total_seconds() / 3600, 1 / 60)
texts = [re.sub(r"^(@\w+\s+)+", "", t.get("text") or "") for t in posts]
top = max(posts, key=lambda t: t.get("likeCount") or 0)
return {
"product": name,
"posts": len(posts),
"posts_per_hour": round(len(posts) / hours, 1),
"topic_share_pct": {k: round(100 * sum(bool(re.search(rx, s, re.I)) for s in texts) / len(texts), 1)
for k, rx in TOPICS.items()},
"most_liked": {"url": top["url"], "likes": top.get("likeCount"), "views": top.get("viewCount")},
"cost_usd": round(len(posts) * 15 / 100_000, 4), # 15 credits per tweet returned
}
if __name__ == "__main__":
ap = argparse.ArgumentParser()
ap.add_argument("names", nargs="+")
ap.add_argument("--pages", type=int, default=5)
a = ap.parse_args()
json.dump([pulse(n, a.pages) for n in a.names], sys.stdout, indent=2)
Questions readers ask
What is a personal AI agent?
An assistant that runs on its own cloud computer, keeps working between conversations, connects to your apps and asks before consequential actions. OpenAI's dots, Meta's Muse, Anthropic's Claude Duet and xAI's Grok Bot all fit that description in their own docs.
What is the best personal AI agent?
It depends on what you need it to reach. Grok Bot is the only one that reads X natively. Claude Duet and OpenAI dots accept remote MCP servers, so they are the most open to your own tools. Meta Muse is the only one with a free tier. Duet has the lowest paid entry ($20 a month Claude Pro) but is a US waitlist preview.
OpenAI dots vs Meta Muse: what is the difference?
Muse is free with paid tiers at $20 and $100 a month and runs in its own app and WhatsApp in the US. Dots come with ChatGPT Pro ($100, $200 or $500 a month) or Business Premium, run on GPT-6 Astra, and can be reached in ChatGPT, Slack, Teams or by call. Dots accept custom MCP servers through ChatGPT Plugins; Meta does not mention MCP and instead lets Muse build custom connectors.
Can Claude Duet or OpenAI dots read Twitter?
Not natively: neither product's docs mention X. Both can use a remote MCP server, so adding https://mcp.twitterapi.io/mcp as a custom connector (Claude) or custom MCP plugin (ChatGPT) gives them tweet search, timelines, mentions, replies, followers and trends at $0.15 per 1,000 tweets.
Does Grok Bot need the X API to read X?
Not for public reads: xAI's docs say Bots search and read public X without connecting an X account. The X plugin, needed for DMs, bookmarks, your home timeline and likes, runs on X API credits on your X developer account, where X's rate card prices a post read at $0.005.
How much do personal AI agents cost?
Meta Muse: free, Power $20, Maximum $100 a month. Claude Duet: included in Claude Pro ($20 a month) and Max (from $100) during the preview. Grok Bot: The X Subscription Premium $30, Super $100, Ultra $200, billed monthly, or a paid Cursor plan. OpenAI dots: ChatGPT Pro at $100, $200 or $500 a month, or Business Premium.
Can my agent post to X through twitterapi.io?
The MCP server exposes read tools. Writes are separate REST endpoints that act through an authenticated session: one /twitter/user_login_v2 login ($0.10, with a proxy you supply) returns login_cookies, then each post, like, retweet or follow is $0.002 (for example /twitter/create_tweet_v2). The call acts as that account, so X can rate-limit, lock or suspend it; keep a human pace, expect occasional re-login, and note billing is per HTTP 200 call. Keep agent posting behind an approval step.
Is a personal AI agent safe to connect to my accounts?
All four vendors describe approval before sending, paying or deleting, and Anthropic warns that content the agent reads can carry prompt injection. Give connectors the narrowest access: Muse lets many connectors be read-only, and an X data API key that only reads public data limits what a confused agent can do.
Continue
- xAI docs: Grok Bot overview (cloud computer, platforms, plans, @bot on X)
- OpenAI: Meet dots (cloud computer, plugins, availability and access)
- Meta: Introducing Muse, personal AI agent (Muse Secure VM, platforms)
- Anthropic: Get started with Claude Duet (access, connectors, pricing and limits)
- Anthropic: custom connectors using remote MCP (plans, request headers)
- X API pay-per-usage pricing (post read, user read, 3M cap)
- Twitter (X) API overview and endpoints
- Grok Bot and the X API: reads and X connector costs
- How to use Claude with the Twitter (X) API
- Hermes Agent with Twitter (X) data
- Connect a custom MCP server to ChatGPT
- twitterapi.io MCP server: 12 Twitter (X) tools
- twitterapi.io pricing and credits
- 01Grok for Startups: what the xAI credits cover, who qualifies, and where Twitter (X) data fits
- 02X Chat API: Building on Encrypted Twitter (X) DMs with the Chat XDK
- 03Grok Bot API: Every Way to Drive a Grok Bot From Code, and How to Feed Your Own Agent Twitter (X) Data
- 04Grok Bot Alternatives: Open-Source and Hosted Agents for Twitter (X)
- 05Muse Connectors: What Exists, Custom Connectors, MCP, and Live Twitter (X) Data
- 06Grok Voice Agent API: How to Call It and Feed It Live Twitter (X) Data
- 07How to Build an AI Twitter (X) Bot with an LLM in 2026
- 08Agent Reach and Twitter (X): What the Twitter Channel Does, What It Needs, and the API Route
Stop reading. Start building.
Starter credits cover real testing on real data. Google sign-in, no card, no application queue.
Get an API keyAlready building with TwitterAPI.io? Publish an honest tutorial or build log about it and earn up to $200 a month in API credits.