| OWNERSHIP |
| License |
Proprietary (xAI) |
Proprietary (Meta) |
Proprietary (OpenAI) |
MIT |
MIT |
Proprietary (Meta) |
Proprietary |
Proprietary (OpenAI) |
Proprietary (Anthropic) |
Proprietary |
Open-source (check repo for exact; community self-hosted) |
Apache-2.0 |
Apache 2.0 (open-source app on GitHub: milind-soni/OpenMausBot). Optional proprietary Cloud plans (Personal / Pro / Max) from SupaMaus for always-on hosting |
Open source on GitHub (composio-community/open-dot); check repo for current license — some reports note no clear packaged license yet |
Proprietary (Spear Street Technology, Inc.) |
MIT |
Proprietary (managed SaaS; formerly MissionControlHQ) |
Proprietary (desktop app; releases via GitHub atmoio/enjoy-releases) |
MIT (open source) |
Proprietary (Manus / Meta ecosystem) |
Proprietary SaaS (polsia.com); open-source self-host variant on GitHub (PolsiaAI/Polsia, Claude Code CLI–driven) |
Proprietary platform (Bankr); open skills/plugins on GitHub (BankrBot/skills, openclaw-skills) |
Proprietary (Pickle, Inc.) |
MIT (open source) |
Proprietary SaaS (runcofactor.com) |
Proprietary desktop app (openswarm.com; signed builds on github.com/openswarm-ai/openswarm). Separate open-source projects also use the OpenSwarm name (e.g. VRSEN/OpenSwarm terminal swarm) — different products |
| Hosting |
Managed cloud by xAI |
Managed cloud (Meta); Muse Secure VM per user |
Managed cloud (OpenAI) |
Self-hosted (local machine or VPS) |
Self-hosted (local, remote, or Hermes Cloud instances) |
Managed cloud (Meta) |
Managed cloud |
Managed cloud |
Managed cloud |
Managed cloud |
Self-hosted |
Fully self-hosted (Docker / E2B / Daytona / Box); managed Cloud waitlisted |
Default: local-first on your Mac/Windows/Linux. Optional: self-host with `npx openmausbot serve` (VPS/Docker/Tailscale) or managed OpenMausBot Cloud (Personal $29 / Pro $49 / Max $99 per month) — always-on Linux workspace so bots run 24/7 with the laptop closed |
Self-hosted on your Mac (app must be open for routines/triggers in current builds) |
Managed cloud (invite-only / waitlist while scaling compute) |
Self-hosted (local Node WebSocket server); optional remote via LAN, Tailscale, or T3 Connect tunnel. Clients: web (app.t3.codes or local), Electron desktop, iOS/Android |
Managed cloud (dedicated workspace / cloud computer for the squad). Primary product is not self-hosted; export/backup available on cancel |
Local-first desktop (macOS 13+ Apple Silicon & Intel, Windows x64). Optional phone/browser remote when desktop is awake and online; end-to-end encrypted device messages on paid plan |
Self-hosted (Node.js server + React UI); optional third-party hosted instances. Single deployment can run multiple isolated companies |
Managed cloud (Manus Cascade harness + optional Cloud Computer) |
Managed cloud for the commercial product (provisions GitHub, Neon DB, Render, email, Stripe Connect). Self-host via Docker + Claude Code CLI for the open-source path |
Managed cloud agent runtime + wallet infrastructure; state keyed to your wallet/account across surfaces |
Managed (iOS app + cloud); Pickle’s computer and work records on provider infrastructure |
Self-hosted: Rust host (`codync-host`) on your Mac or Linux; optional free end-to-end-encrypted relay for remote phone access (or direct Wi‑Fi / Tailscale) |
Managed cloud for suite runs / CI / scheduled fuzzing; local CLI pairs with your machine for live browser sessions |
Local desktop on your Mac or Windows machine — agents, browsers, and apps run on your computer; no required cloud agent host |
| Machine model |
Dedicated remote computer / sandbox per bot (xAI infrastructure) |
Dedicated secure Linux virtual machine with its own browser, file system, terminal, and storage; browser visible to the user; separate Sentinel process for outbound action checks |
Dedicated cloud computer + browser per dot; can also connect to the user’s laptop with permission; inspectable workspace |
Runs on host or connected tools; extensible with skills/plugins |
Multiple execution backends (local, Docker, SSH, Singularity, Modal) |
Cloud-hosted; limited true computer-use compared with dedicated sandboxes |
Cloud sandbox / browser + computer-use environment per task |
OpenAI sandboxes / computer-use environments |
Claude computer-use / sandbox environments |
Cloud agents with tool access (no full personal desktop by default) |
Isolated Linux desktop / sandbox per agent |
One sandboxed computer per bot (or shared Team Computer) — browser, shell, graphical desktop |
Free/local: your computer, optional per-bot cloud desktop or isolated VM from the Computer panel. Cloud plans: always-on shared-CPU Linux machine (Personal 2 vCPU/2 GB; Pro 4 vCPU/4 GB; Max 8 vCPU/8 GB) plus included cloud computers with live desktops (1 / up to 4 / up to 8 concurrent; 50 / 200 / 500 computer-hours per month) |
Per-dot browser that stays logged in; watchable Computer tab with human takeover for login/CAPTCHA; not a full cloud VM like OpenAI Dots / Grok Bot |
Cloud + device access (phone + computer use in the same way a human would); connects to email, messaging, screen, audio, location and more |
Runs on the host machine; agents execute via their native CLIs (no separate sandbox VM per bot by default). Git worktree isolation per thread |
Dedicated cloud infrastructure for the squad; separate browser profile (and own logins/files) per teammate on shared team computer |
Runs coding agents on the host via installed CLIs (Claude Code, Codex, Grok Build). No separate cloud sandbox per bot; project terminals/previews managed in-app |
Orchestration layer only — agents run via adapters (Claude Code on host, Codex, Cursor, OpenClaw, shell, HTTP heartbeats). No built-in cloud desktop per agent; workers bring their own runtime/computer |
Dedicated computer workspace per agent; agents also get their own phone number, email address, and wallet/card — independent identity rather than signing into the user’s accounts only |
Platform-managed company stack + agent cycles; commercial path includes persistent cloud computer / desktop state for agents. Open-source path runs agents as Claude Code subprocesses on your host |
Web-native agent workspace: persistent filesystem in UI, code sandbox, scheduled automations — not a full Linux desktop like Grok Bot, but a crypto execution environment with browser/research tools |
Dedicated computer per Pickle for browsing, booking, ordering, paying; phone calls from Pickle numbers; work records (steps, pages, results) reviewable by you |
Your real computer — coding agents run locally with your logins and project folders; remote screen (WebRTC) from phone; built-in `computer` tool for bots |
Real browser driven by the Cofactor agent (local via CLI or platform runs); sessions become commit-able deterministic traces — not a general-purpose personal cloud desktop |
Your real computer as an infinite canvas of agent cards: each agent owns browser sessions, apps, files, terminals; parallel browsers and on-demand apps |
| State ownership |
xAI-controlled; user data subject to xAI terms |
Meta-controlled; Meta states Muse data is not shared with ads system and emphasizes built-in privacy/security design — still provider-hosted |
OpenAI-controlled; enterprise options for private intelligence / no-retention tooling |
User-owned (local files, memory, configs) |
User-owned (local SQLite / pluggable memory backends) |
Meta-controlled |
Provider-controlled |
OpenAI-controlled |
Anthropic-controlled |
Provider-controlled |
User-owned |
User-owned (Postgres + DATA_DIR workspaces, browser profiles, audit logs) |
Local app: data in ~/.openmausbot on your disk. Cloud: workspace on provider machines; AI usage still on your Claude/ChatGPT/Grok accounts or API keys (Cloud does not resell tokens) |
Local on your Mac; passwords in macOS Keychain (model never sees plaintext) |
Provider-controlled; terms grant license to use Materials for training/fine-tuning |
User-owned (sessions, threads, git state on your machine) |
Provider-hosted workspace; FAQ states workspace data is not used as training material; export available before cancel |
User-owned local files — conversations, docs, recipes, and project state live in a local .enjoy folder (plain files) |
User-owned (your deployment, tickets, audit log, org data) |
Provider-controlled; user sets tools, permissions, and approval gates |
Commercial: provider-hosted company state, memory, and (in some terms) payment flows through Polsia balance. Self-host: user-owned |
Wallet and on-chain assets are yours; agent memory/files/automations live on Bankr’s backend tied to your account/wallet |
Provider-hosted memory and work records; privacy policy states no training on your data; sensitive categories (health, finances, exact location) gated from social sharing |
Bots, transcripts, memory, and authorization live in local SQLite (`~/.codync`); phone only receives E2E-encrypted frames; notification text sealed to the phone key |
Flows, traces, videos, and reports on Cofactor’s platform; local traces can be committed to your repo |
Local workspace (projects, pins, recents, memory if enabled). Logins saved for agents stay off until you enable them; agents fill credentials without seeing passwords |
| CONTROL |
| Approval model |
Human-in-the-loop with takeover; bots ask when needed |
User stays in control; approve before sensitive actions (sending email, making purchases); complete audit trail of done and planned work; opt-in connectors with revoke |
Custom rules for what the dot may do alone vs when to ask; sensitive actions (e.g. password changes, permanent deletes) require explicit consent |
Configurable; community skills often include safety boundaries |
Configurable safety; container hardening and isolation options |
Platform-managed safety filters and policies |
Task-level autonomy with human review options |
Human-in-the-loop + safety layers; configurable autonomy |
Strong constitutional AI + human approval patterns for risky actions |
Human approval workflows for actions |
Configurable isolation and human oversight |
Configurable; request_takeover + full human desktop takeover |
Inline Allow / Deny (or Always allow) cards for shell commands, file edits, and risky actions — on desktop and from phone when paired |
Rules (e.g. “ask before replying to email”); small model checks risky actions; approve/deny from chat cards. Reads freely via Composio; asks before send/post/pay/change |
Highly proactive / resourceful by design; can reset passwords, complete purchases, fill paperwork, make calls with relatively little friction (users report aggressive autonomy) |
Provider-native approvals + dual runtime modes (Full Access / Supervised); approval prompts surfaced in the UI |
Human-in-the-loop via tickets/approvals (draft-for-review for email; spending and real-world purchases gated by briefing); phone as decision device for approvals |
Provider-native agent approvals; Enjoy is the workspace surface, not a separate policy engine |
Governance layer: budgets per agent, ask-first / allow / off per connector action, human approve strategy and spend caps; pause / resume / override / reassign / terminate |
User controls tools/permissions; sensitive actions (payments, etc.) under user-set rules; agent hands work back when a decision is needed |
Morning briefings / reports; founder reviews before publish in many workflows; commercial product still expects human oversight of what ships. Open-source: you control the host and CLI |
Security layer screens txs (malicious contracts, phishing, unusual patterns, prompt injection) before sign; Club/Max Mode gates heavier agent API use; social surfaces ignore pure greetings |
Designed to check with you before spending money and before significant/irreversible steps; Link (Stripe) payments require explicit approval per charge |
Approval cards in chat: Allow once / Always allow / Deny when an agent wants to run a command or change files; notify only on “needs you” or “done” |
QA-oriented: suite results, video evidence, flake filtering before alerting; role-based flow runs (Owner / Admin / Member / Viewer) to assert access boundaries |
Human-in-the-loop for risky / outward actions (e.g. send email, sensitive commands); safety modes by risk level; unified approval surface across the swarm |
| Model choice |
Locked to Grok family (Grok 4 / Grok 4.6 etc.) |
Locked to Meta’s Muse Spark (agentic model); stronger backend model (internally ‘Watermelon’) planned |
Locked to GPT‑6 Astra (and OpenAI stack: Codex, ChatGPT Work tools) |
Multi-provider (Claude, GPT, Gemini, Grok, Ollama, etc.) |
Highly flexible (Nous Portal, OpenRouter 200–400+ models, Anthropic, OpenAI, Grok credits, local) |
Locked to Meta Llama family / Meta AI models |
Provider-managed (often multi-model under the hood) |
Locked to OpenAI models (GPT-4o, o-series, etc.) |
Locked to Claude family (Opus, Sonnet, Haiku) |
Provider-managed multi-model |
Model-agnostic (bring your own) |
Fully flexible via Pi harness (Claude, GPT, Grok, local, OpenRouter, ChatGPT/Copilot/SuperGrok OAuth) |
Per-bot engines via CLIs you already have (Claude Code, Codex, Grok, Cursor, and more) or API keys / local models; switch models mid-conversation. Unlimited bots on all plans |
Your OpenAI API key or OpenRouter (open models such as Kimi, DeepSeek, Qwen). No ChatGPT Pro required |
Proprietary core model trained for personal life nuances |
Bring-your-own agent CLIs — Claude Code, Codex, Cursor, Grok Build, OpenCode (and forks add more). Switch models/providers mid-thread |
Bring-your-own AI: ChatGPT (Codex), Claude, Claude Code, Grok/SuperGrok, Gemini, GitHub Copilot, Kimi, MiniMax, Z.AI, Qwen Cloud, Cloudflare Workers AI, OpenCode, OpenRouter. Per-agent and per-schedule model overrides; multi-account stacking and ordered fallback chains |
Bring-your-own agent CLIs — Claude Code, Codex, Grok Build (using existing Claude/ChatGPT/Grok subscriptions). Switch agent mid-conversation |
Fully bring-your-own agent runtime — Claude Code, Codex, Cursor, OpenClaw, Hermes, OpenCode, Gemini, HTTP/bash, etc. Model choice is whatever each hired agent uses |
Provider-managed (Manus / Cascade stack); not bring-your-own model |
Primarily Anthropic Claude / Claude Code CLI (OAuth). Commercial platform is Claude-centric; self-host follows whatever the CLI is authenticated to |
Bankr LLM Gateway (Claude, GPT, Gemini, Grok, open weights, etc.) billed from LLM credits; Max Mode can pick models per prompt. Gateway also usable by Claude Code / OpenClaw / Cursor |
Provider stack (Google, OpenAI, Anthropic, xAI and infra such as Azure, Baseten, Cerebras, OpenRouter per privacy policy) — not user-selectable per task |
Bring any ACP coding agent (Claude Code, Codex, Cursor, Gemini, Copilot, OpenCode, Pi, Grok Build, ~40 more) with the logins you already have; mix agents per bot |
Platform agent + integration with your coding tools (Claude, Cursor); not a user-swappable multi-model personal agent roster |
Bring your own — Claude, ChatGPT, or Gemini subscription sign-in, or API keys (Anthropic, OpenAI, Google, OpenRouter / custom). New Claude chats default to Sonnet 5.5 in recent builds |
| Action layer |
Full computer use (browser, terminal, desktop), tool integrations |
Browser use on Secure VM, connectors/APIs, can build its own tools/code, shopping with one-time Stripe card numbers, email, calendar, forms, bookings |
Own cloud computer/browser, 4,000+ app plugins, optional laptop connection, Codex / Work tools for research, docs, software |
Tool use, browser, shell, messaging integrations, large skill library (ClawHub) |
47+ built-in tools, browser automation, shell, MCP, subagents with isolated terminals |
Chat + integrated tools (search, image gen, some app actions inside Meta ecosystem) |
Strong browser / computer-use operator for one-shot or multi-step tasks |
Computer use, browser, code interpreter, advanced tool calling, file work |
Computer use, browser, tool use, file/desktop control, Artifacts |
Strong on email, calendar, CRM, web tools, and business app integrations |
Full Linux desktop control, browser, terminal, files |
Browser, terminal, files, graphical desktop + optional Composio apps |
Agent CLIs on local or cloud machine; Computer panel (cloud desktop / VM / host control); Composio-style connected apps (hundreds); voice calls and spoken replies |
Per-dot browser, Composio connectors (Gmail, Calendar, Slack, Notion, GitHub + ~1,500 apps), optional voice calls that continue after hang-up |
Phone + computer use, messaging (iMessage primary), calls, bookings, shopping, form-filling, app connections |
Whatever the underlying coding agent can do (file edit, terminal, browser tools if the CLI supports them) + T3’s git worktree isolation, diff viewer, one-click commit/push/PR |
Tools/integrations, browser use on cloud profiles, email (optional per-agent inboxes), research tools, MCP/custom credentials; connects to business tools with scope presets and per-agent access |
Whatever the underlying coding agent can do (edit, terminal, tools) plus Enjoy’s project management: multi-agent threads, docs/recipes, local previews/servers, check-ins |
Delegates to hired agents’ tools; Connectors (Gmail, Calendar, GitHub, etc.) with per-agent account and action permissions |
Own phone (calls/SMS), own email, own wallet (payments with limits), dedicated computer/browser workspace, connectors (Gmail, Trip.com, Oura, MyFitnessPal, Notion, Slack, etc.), routines |
GitHub code + PRs, social posts, cold email, Google/Meta ads, inbox/support, Stripe finance, competitor research, web tools / MCP |
First-class crypto: swaps, bridges, limit/stop/DCA/TWAP, Hyperliquid & Avantis perps, Polymarket, NFTs, token deploy + fee claims, transfers to ENS/social handles, arbitrary contract calls, Merkl rewards, web research |
Own web browser, connected accounts/cards, calendar, messaging, phone calls (transcribed, disclosed as AI), research/book/order/pay flows |
ACP agents on local projects + computer tool + remote screen control; not a general consumer booking agent |
Browser automation (click, type, assert), seed data, multi-role runs, issue filing to Jira/Linear/Azure DevOps with agent-ready fix prompts |
Agentic browsers (rebuilt form-fill, frames, pop-ups, one-shot send confirmation), apps spawned on request, files, terminals, connected tools; parallel multi-browser research |
| MEMORY AND SKILLS |
| Memory |
Persistent per-bot conversation + memory |
Persistent across conversations; learns preferences, reflects on goals, proactive suggestions from context |
Starts from ChatGPT memory; learns preferences, standards, and working habits from feedback over time; project context across channels |
File-backed / Markdown session memory with isolation modes |
Persistent across sessions (SQLite + FTS; pluggable backends, optional knowledge graph) |
Conversation memory within Meta accounts / apps |
Session / task memory; less emphasis on long-term personal memory |
ChatGPT memory + custom GPTs / project memory |
Project / conversation memory; growing long-term features |
Agent memory across tasks and conversations |
Persistent local memory |
Persistent per-bot conversations, memory, and history |
OpenMausBot holds the full conversation notebook locally (or on your Cloud workspace) and feeds each model what it can hold — not left only inside the provider CLI |
Per-dot memory of you and recurring tasks; skills saved for repeated work |
Long-running continuous relationship / single thread with deep personal context |
Persistent threads / sessions managed by T3; long-term memory is whatever the chosen agent CLI provides |
Persistent workspace context, missions, tickets, docs, and agent history across sessions |
Project-local state in .enjoy (threads, docs, recipes); long-term agent memory is whatever the chosen CLI provides |
Company/task history, tickets, comments, immutable audit trail; agent memory lives in the underlying agent runtime |
Persistent per-agent state across sessions; multi-agent shared goals in group chat |
Shared persistent memory across agents and companies on an account; holds context across daily cycles |
Durable memory across conversations; same agent state on web, X, Telegram, CLI |
Core product — living memory of conversations and life context; evolves with use; optional broader Pickle OS / enclave memory story on company sites |
Per-bot memory that carries across sessions; host-owned, local |
Deterministic traces and flow library; self-healing when UI changes — product memory is the regression suite, not a personal life graph |
Opt-in (new installs default off): agents keep a fact only when they decide it is worth keeping; no background scraping. Review/delete stored notes in Settings |
| Skills |
Routines / workflows the bot can learn and reuse |
Goal → plan → autonomous progress; builds tools as needed; connector library + API/browser fallback — not a user-authored skill marketplace |
Scheduled tasks, event monitoring, proactive research (read-only on connected apps when unprompted); not a user-authored public skill marketplace |
Large community library (ClawHub); mostly human-authored, installable skills |
Self-improving — agent auto-creates, updates, and refines skills from experience |
Built-in capabilities; limited user-authored skill system |
Task templates and autonomous workflows |
Custom GPTs, Actions, and agent workflows |
Custom instructions, Projects, tool definitions |
Pre-built + custom agent skills / workflows |
User / community defined skills and routines |
Markdown routines (teach once → readable/editable/committable) |
Per-bot skills, routines, webhooks; portable bot teams; botmrr.io-style catalog mentioned for sharing teams |
Dots can save skills for tasks they repeat; not a large public skill marketplace like OpenClaw ClawHub |
Trained for everyday life tasks (follow-ups, travel, home services, admin, negotiation) |
Relies on the skills/tools of the connected agent CLIs; T3 itself is the control surface, not a skill runtime |
Playbooks / specialist roles designed with the Lead agent; schedules and recurring runs; not a public skill marketplace like ClawHub |
Recipes and project workflows in the local folder; relies on connected agent capabilities rather than a public skill marketplace |
Company templates (pre-built org packs); connectors and role job descriptions; not a ClawHub-style public skill marketplace |
Routines and connected-life flows; merchant QR → agent pattern; not a public skill marketplace |
Fixed specialist roles on schedules (orchestrator, planning, social, outreach, support, ads, code, finance, competitor research); not a public skill marketplace |
Installable skills (GitHub catalog + in-product Skills tab); Bankr skill for OpenClaw/Claude Code so external agents inherit trading/wallet tools |
No public skill marketplace; capabilities grow with level/trust and connected accounts rather than user-authored skill packs |
Inherited from whichever coding agent each bot runs; Codync itself is the messaging/approval/orchestration layer |
Flows/properties built from NL, tickets, PRDs, or Chrome Extension recording; CLI skill templates for agents (`@runcofactor/cli`) |
Templates and swarm apps (Lead Finder, Problem Validator, Post Harvester, etc.); convert agent runs into repeatable one-click workflows |
| COORDINATION |
| Multi-agent handoff |
Supported (bots can coordinate / hand off) |
Primarily single personal agent (not a multi-bot roster like Grok Bot / Squad); can juggle multiple tasks in one continuous relationship |
One primary dot at launch that can delegate parallel work; OpenAI envisions teams of dots later. ChatGPT Space for human + dot collaboration on shared project knowledge |
Strong gateway / multi-agent orchestration |
Subagents + A2A support; peer-style delegation |
Limited / not a primary focus |
Limited (more single-agent task runner) |
Emerging multi-agent patterns inside OpenAI stack |
Limited native; possible via API orchestration |
Multi-agent teams supported |
Supported via peer or sub-agent patterns |
Strong — spawn peer bots (own thread + computer) or short-lived subagents |
First-class — unlimited named bots; group rooms; @mentions; bot-to-bot hand-offs you approve; threads under each bot |
Multiple dots with different jobs can pass work to each other |
Primarily single continuous agent; orchestration is internal rather than multi-bot roster |
Parallel agents across projects/worktrees; orchestration is ‘run many coding agents side-by-side’ rather than multi-bot personal teams |
Strong — Lead Agent coordinates; specialists claim tickets on a shared mission board, @-mention style routing, threaded discussion |
Multiple agent threads in one workspace; switch brains mid-thread; not a multi-bot personal-life roster |
Core product — org chart, reporting lines, CEO strategy → task creation → delegation; tickets, queues, @-style coordination across roles |
Supported — several specialized agents can share a goal in a group chat and hand work to each other while the user sets direction and final calls |
Core design — orchestrator plans; specialists execute on staggered or nightly cycles; shared company state |
Ecosystem of agent tokens/agents on leaderboard; not a personal multi-bot roster like Grok Bot. One Bankr agent per account with shared state across channels |
Social multi-Pickle world (friends’ Pickles, community board) for plans and intros — not a work multi-bot roster like Grok Bot |
First-class — many bots side by side; group chats (answer in turn, `@name`); bots ask each other via built-in `team` MCP (`ask_bot`); threads branch without cluttering main chat |
Hand-off to coding agents via filed issues with fix prompts; not multi-bot personal teammates like Grok Bot |
First-class — many agents on one canvas; parallel specialists; sub-agents stop when parent stops; orchestrated big jobs (e.g. multi-source problem validation) |
| Channels |
Native app / messaging-style interface; multi-platform clients |
Dedicated Muse app (iOS/Android), muse.ai web, WhatsApp; AI glasses coming soon |
ChatGPT (web, desktop, mobile after setup), Slack, Microsoft Teams; voice calls; texting (iMessage/RCS) on waitlist |
25+ messaging platforms (WhatsApp, Telegram, Slack, Discord, iMessage, etc.) |
12+ (Telegram-first, Discord, Slack, WhatsApp, Signal, Email, CLI, etc.) |
WhatsApp, Instagram, Messenger, web, devices with Meta AI |
Web app / API primarily |
ChatGPT app, web, API, some enterprise integrations |
claude.ai, API, Slack (via integrations), desktop apps |
Email, Slack, web app, phone, etc. |
Local UI + possible messaging bridges |
Web app, Electron desktop, Expo mobile; voice mode (ElevenLabs/OpenAI/Cartesia) |
Desktop (macOS, Windows, Linux), iOS and Android companions, optional remote via serve/Tailscale/Cloud; Discord community for free tier |
Mac app chat, voice calls; app-centric (not a full messaging-gateway product) |
iMessage / text + voice calls as primary interface; no new UI to learn |
Web app, Electron desktop, native mobile (iOS/Android); remote control over network/Tailscale/T3 Connect |
Dashboard chat (primary), optional Telegram and Discord bots, iOS app; read-only share links for observers |
Native desktop app (primary); paid plan adds phone and browser clients (desktop must remain online) |
Web dashboard (primary); mobile-friendly monitoring; agents themselves may expose chat channels (e.g. OpenClaw workers) |
Cue app (macOS + mobile; iOS in App Store review), web; agents can use their own phone/email as channels |
Web dashboard + live activity stream; morning email briefings; agents act on external channels (email, X, ads) |
bankr.bot terminal, @bankrbot on X, Telegram @bankr_ai_bot, Farcaster, CLI (@bankr/cli), Agent API |
iOS app (voice + text primary); Pickle-to-Pickle / community in the 3D world |
iPhone/iPad app (App Store), native Mac (SwiftUI), Linux (GTK), terminal UI over SSH |
Web app (app.runcofactor.com), CLI inside Claude/Cursor, Chrome Extension, CI hooks |
Native desktop (macOS, Windows; Linux not yet); panels + canvas UI; not primarily a WhatsApp/Telegram gateway product |
| Scheduling |
Routines and scheduled work supported |
Continues work in background after app close; event- and schedule-driven follow-ups; notifies when something meaningful needs input |
Always-on; scheduled tasks and supported event monitoring; works while user is away |
Heartbeats / cron-style jobs supported |
Natural-language scheduling and recurring routines |
Basic reminders / limited proactive scheduling |
Supported for recurring or queued tasks |
Limited native; more via API or external orchestration |
Limited native scheduling |
Strong native scheduling and recurring agents |
Supported |
Routines via Graphile Worker |
Routines and webhooks on local machine; Cloud plans run scheduled tasks even with the laptop off |
Scheduled routines (e.g. weekday inbox/calendar brief) and event triggers (email, GitHub issue) via Composio — currently only while the app is running |
Proactive (calls/texts you, follows up, works overnight) |
Session/thread oriented; not a general cron/routines system like Hermes or Rakazo |
Native schedules + heartbeats; agents work offline 24/7 |
In-app check-ins / on-demand flows; not a general 24/7 personal-agent scheduler |
Heartbeats and routines; agents wake on schedule / tickets; 24/7 capable if workers and host stay up |
Agents keep working after user logs off; routines for repeatable flows |
Strong — daily/nightly autonomous cycles, plus per-agent intervals (e.g. social every 2h, support every 3h) |
Strong — limit/stop/DCA/TWAP orders and scheduled agent commands that run while you sleep |
Proactive follow-ups and task continuation via work records; not a full cron/routine editor in the consumer pitch |
Routines on a schedule or webhook |
Strong — PR runs, scheduled full regression, nightly fuzzing of the app |
Repeatable workflows from past agent runs; not primarily a 24/7 cloud always-on laptop-closed product |
| RUNNING IT |
| Setup |
Subscription-based (SuperGrok Heavy / high-tier plans); waitlist / early access. Primary clients are native desktop (macOS/Windows) and iOS apps — no specific browser required for the control UI. The bot’s own computer uses a managed cloud browser. |
US-only at launch: download Muse app (iOS/Android) or use muse.ai / WhatsApp. No technical setup; connect apps and grant access as needed. Web UI works in modern browsers. Free tier covers most everyday use; Power $20/mo and Maximum $100/mo for heavier automation. |
Create dot in ChatGPT desktop app (not mobile-create). Available to Pro and Business Premium in eligible markets (Pro excludes EEA, UK, Switzerland at launch); Enterprise when admin enables. One dot included at no extra seat cost. Web/desktop work in modern browsers; mobile interaction after setup. |
Relatively fast (npm / onboard wizard); ~30 min typical. Agent browser control requires a Chromium-based browser (Chrome, Brave, Edge, or Chromium) — Safari and Firefox are not supported (CDP). Managed profile or Chrome-extension relay both expect Chromium. |
Single install command; 2–4 hours for full assembly typical. Web dashboard works in any modern browser. Local/CDP browser automation and the official Chrome connector need a Chromium-family browser (Chrome, Brave, Edge, Chromium); Safari is not supported for the connector. |
Zero (already inside Meta apps). Web interface works in any modern browser (Chrome, Safari, Firefox, Edge). |
Sign-up + credits. Web app works in modern browsers. “My Browser” / Browser Operator connector requires the extension on Chrome or Edge. |
ChatGPT Plus / Team / Enterprise subscription. Web app works in any modern browser (Chrome, Safari, Firefox, Edge); also native apps. |
Claude Pro / Team / API access. Web app works in any modern browser; computer-use runs in Anthropic’s managed environment (not your local Safari/Chrome). |
Sign-up and connect accounts. Web app works in any modern browser (Chrome, Safari, Firefox, Edge). |
Self-host (Docker / local). Control UI is typically web-based (any modern browser). Agent browser automation, when used, generally expects Chromium-based browsers. |
Clone + Node 22 / pnpm / Docker; still early beta. Control UI (web) works in any modern browser (Chrome, Safari, Firefox, Edge). Each bot’s sandbox ships its own browser (Chromium inside Docker/E2B/etc.) — you do not need a local Chrome install for the agents. |
Download .dmg/.exe/.deb or `npx openmausbot` (Node 24+); sign in to Claude/Codex/Grok CLIs or paste API keys. Optional phone pairing. Cloud: create OMB account and subscribe (Personal/Pro/Max). Chromium-family browsers for computer-use where used; native app is the main UI. |
Clone/build Mac app from GitHub (Node 22+, pnpm; Chrome or Playwright Chromium). Supply OpenAI or OpenRouter API key. Modern Chromium for the agent browser; Safari is not the automation target. |
Invite-only / waitlist (instinct.co); existing members can invite. Primary interface is iMessage / phone / voice — no browser required for day-to-day use. Any web surfaces work in modern browsers. |
npx t3@latest (or desktop installers via brew/winget/GitHub releases). Requires at least one authenticated provider CLI. Control UI (web) works in any modern browser (Chrome, Safari, Firefox, Edge); desktop/mobile apps do not depend on a specific system browser. Agents themselves run as CLIs on the host. |
Sign up at squad.so → connect AI provider(s) → ~5 min provisioning → ~10 min Lead Agent onboarding chat. Web dashboard works in any modern browser (Chrome, Safari, Firefox, Edge). iOS app on the App Store. Claude Code path may need Node.js/terminal for setup-token. |
Download Mac (.dmg) or Windows installer from enjoy.dev / GitHub releases. Install and authenticate at least one of Claude Code, Codex, or Grok Build. Free: one project, desktop only. Unlimited $14.99/mo for more projects and remote clients. Control UI is the desktop app; web/phone on paid plan work in modern browsers. |
npx paperclipai (or onboard flow); configure DB, hire CEO first, then specialists. Web UI works in any modern browser. Requires at least one agent adapter (e.g. Claude Code installed for local Mac runs). Company templates importable from paperclipai/companies. |
cue.im — download app / sign in (early access with invite code, free for now). Name agents; they provision email (and phone/wallet where available). Web works in modern browsers. Cloud Computer is a separate purchasable resource for always-on work. |
Commercial: sign up at polsia.com, describe idea or “surprise me,” agents provision stack. Open-source: clone PolsiaAI/Polsia, Docker Compose, Claude Code CLI authenticated. Web UI works in modern browsers. |
bankr.bot → sign in (email / X / Farcaster / Telegram) → wallet created. Or npm i -g @bankr/cli && bankr login. Optional: install Bankr skill into OpenClaw/Claude Code. Terminal works in modern browsers. Free tier ~5 messages/day on terminal; Club ~$20/mo or Max Mode + LLM credits for heavier use. |
iPhone App Store install; raise from Lv.1. Free with in-app purchases / optional Pickle Plus (Apple billing). Modern iOS only — not a desktop browser agent product. |
Install host on Mac/Linux (Homebrew / releases); install coding agents you want; pair iOS app via QR or access request. Optional Tailscale or free relay. Native apps — not a browser-required control surface for the host. |
Sign up at runcofactor.com; CLI for local browser pairing; Chrome Extension for recording flows. Chromium/Chrome is the automation browser. Docs at docs.runcofactor.com. |
Download desktop app from openswarm.com / GitHub releases; sign in with Claude/ChatGPT/Gemini or paste API keys. Optional: import Chrome profile or password-manager export for agent logins (Privacy setting). Chromium-family agent browsers. macOS and Windows today. |
| Ops burden |
Very low (fully managed) |
None (fully managed consumer product) |
Very low (fully managed) |
Medium (self-host + model keys) |
Low–medium (especially on serverless/idle-friendly backends) |
None |
Very low |
Very low |
Very low |
Very low |
Medium |
Medium (Postgres, API, worker, sandbox supervisor) |
Low on free desktop (keep machine on for always-on work). Medium if self-hosting serve. Low on Cloud (managed always-on machine) |
Medium — build from source, keep app running for schedules, manage API keys and Composio |
None (fully managed consumer product) |
Low for local use; medium if you expose the server remotely |
Very low (fully managed) |
Low for local use; phone access requires desktop left on and connected |
Medium (self-host Node server, DB, keep agent runtimes healthy); lower if using a hosted Paperclip instance |
Very low (fully managed) |
Low on commercial (managed); medium on self-host (Docker, Claude CLI, integrations, reviewing agent output) |
Very low for trading/chat; medium if you run self-funding agent tokens and monitor fee/LLM economics |
Very low (fully managed consumer app) |
Low–medium: keep host running, manage agent logins, pair devices; no cloud ops beyond optional relay |
Low for managed suite; medium if you own local CLI + CI wiring and review self-healed flows |
Low–medium: keep the desktop app running for the swarm; manage saved logins and approval habits; local machine must stay on for work |
| Cost |
High (hundreds of USD/month tier; metered usage) |
Free tier for most users; Power $20/month; Maximum $100/month. No ads in Muse; Meta exploring commerce revenue |
Included with ChatGPT Pro (from ~$100/mo) or Business Premium; dot conversations do not count toward ChatGPT message limits; Codex/Work tasks count as usual. No separate per-dot fee at launch |
Free software; only LLM API / local model costs |
Free software; very cheap idle cloud instances; only inference costs |
Free (with Meta account) or bundled; no separate agent seat fee |
Credit-based (free tier + paid plans from low tens of USD/month) |
Subscription + usage (Plus ~$20, higher tiers for heavier agent use) |
Subscription (Pro ~$20) + API usage for heavier agent workloads |
Subscription / usage-based (personal to team pricing) |
Free software + your compute and model costs |
Free software; only LLM keys + optional remote sandbox costs; unlimited bots |
App free forever (Apache 2.0). Cloud: Personal $29/mo · Pro $49/mo · Max $99/mo (cancel anytime). AI usage never included — bring your own provider accounts. Voice minutes and computer-hours are fair-use by plan (e.g. Pro ~1 hour speech, 200 computer-hours). Team $169/mo (5 seats) and Business plans also exist |
Software free (self-host); you pay model API + optional Composio. No ChatGPT Pro seat required |
Not publicly listed (private access / scaling phase) |
Free software (MIT). Only cost is your existing Claude/Codex/Cursor/Grok/OpenCode subscriptions |
$99/month flat + your own AI subscriptions (no Squad token markup). 7-day money-back. Research-tool credits and optional email add-on may apply within caps |
Free (1 project) or $14.99/month unlimited. Provider subscription costs separate (Claude / ChatGPT / Grok) |
Free software (MIT). Only costs are your compute + whatever AI subscriptions/API the hired agents use. Some hosted offerings exist at low monthly fees |
Early access free with invite. Long-term pricing not fully published; Manus Cloud Computer and credit-style usage may apply after EA. Early reports mentioned ~$20/mo as a possible post-EA figure — confirm in-product. |
Commercial: free explore tier; Pro around $49/mo (one nightly autonomous task + on-demand credits in published plans); some terms include ~20% share of agent-generated economic activity / payments routed via Polsia. Self-host: free software + Claude subscription/compute |
Terminal free messages limited; Bankr Club ~$20/mo for agent API/skills; LLM gateway pay-as-you-go credits (top up from wallet). Gas often sponsored on supported chains within daily limits. Token-launch path: trading fees can fund LLM usage (self-sustaining loop) |
Free tier + IAP / subscription via App Store; optional Pickle OS Pro / hardware (Pickle 1 AR glasses) is a separate product line and not required for the agent app |
Software free (MIT). You pay only the coding-agent subscriptions/API usage you already use. Relay free. |
Commercial SaaS (talk-to-sales / waitlist positioning on site); exact public tiers not fully listed — expect team/usage pricing typical of QA platforms |
App free at Product Hunt launch; you pay your model subscriptions/API usage. Claims of lower cost per task vs some browser-agent baselines in their own benchmarks |
| Security risk |
High privacy surface: Canadian Privacy Commissioner found xAI/X violated privacy law over non-consensual sexualized deepfakes; documented prompt-injection + encrypted-instruction data-exfiltration attacks; shared conversation URLs have been publicly indexed; class-action claims of transcript sharing with third parties; model can surface personal addresses/dossiers with minimal prompting. Managed hosting reduces self-host RCE risk but concentrates trust in xAI. |
High trust surface by design: Meta holds a dedicated VM, connectors to email/calendar/payments/health, and agent-driven purchases. Mitigations claimed: isolated Muse Secure VM, credential store the agent cannot read, one-time cards at checkout, Sentinel gate on outbound actions, no ads use of Muse data. Residual risks are Meta’s broader privacy history, over-permissioned connectors, prompt injection inside the VM, and dependence on Meta’s isolation claims. Competition framing explicitly targets OpenClaw/Instinct trust vs convenience tradeoff. |
Managed OpenAI profile: cloud computer + broad plugin access. Safeguards include default protections against malicious instructions, custom allow/ask rules, and explicit consent for high-impact actions. Residual risks are classic prompt injection, over-permissioned plugins, and OpenAI data-handling policies (enterprise private-intelligence options mitigate retention concerns). Lower self-host RCE surface than OpenClaw; higher concentration of trust in OpenAI. |
Critical / actively exploited: CVE-2026-25253 (CVSS 8.8) one-click RCE via WebSocket gateway token theft; 30k–42k+ publicly exposed instances; ClawHavoc supply-chain campaign with hundreds of malicious ClawHub skills (infostealers, Atomic macOS Stealer, crypto-wallet theft); plaintext credential storage common; indirect prompt injection via messaging channels; 500+ registered vulnerabilities. Highest real-world attack surface among open-source agents. |
Elevated: ~27 NVD CVEs (highest ~7.3); unauthenticated API server when key unset; CORS wildcards; browser private-network SSRF bypass; MCP-config persistence backdoors on misconfigured public instances; YOLO mode removes approvals and has been used in real post-exploitation; dependency CVEs; display-name allowlist bypasses on some platforms. Strong container isolation is the primary boundary, but operator misconfiguration (exposed dashboard/API as root) has led to live compromises. |
Moderate platform risk: data subject to Meta’s broad privacy practices and advertising ecosystem; limited true computer-use reduces RCE/sandbox-escape surface; primary concerns are account compromise, prompt injection within chat, and Meta’s retention/use of conversation data. |
Moderate: managed cloud sandbox reduces self-host exposure; residual risks are prompt injection inside the sandbox, potential data retention by the provider, and any sandbox escape or tool-abuse bugs. |
Moderate–managed: strong enterprise controls available (SOC2, data-processing agreements, no-training options on higher tiers); residual risks are classic LLM prompt injection, tool-abuse inside the sandbox, and OpenAI’s own data-handling policies. |
Lower relative risk among managed offerings: constitutional AI + explicit approval flows for computer-use; enterprise privacy options; residual prompt-injection and sandbox tool-abuse risks remain. |
Moderate: heavy OAuth access to email/calendar/CRM makes credential and data-exfiltration impact high if the agent or provider is compromised; classic prompt-injection and over-permissioned tool risks. |
Medium (typical self-hosted agent profile): isolation quality depends on the chosen sandbox (Docker/VM); prompt injection and tool abuse can still act inside the sandbox; credential/files in the agent environment are at risk if the sandbox is escaped or misconfigured. |
Early-beta / medium-high: self-hosted stack (Postgres, Graphile Worker, sandbox supervisor) inherits typical web + container risks; Docker socket or misconfigured E2B/Daytona exposure can escalate; Composio OAuth tokens and browser profiles inside sandboxes are high-value targets; prompt injection remains possible. |
Local-first design is strong (data on disk, secrets write-only in UI, approval cards). Cloud adds provider-hosted workspace risk — same class as other managed agent clouds. Residual risks: over-broad Always-allow, Composio OAuth scope, remote pairing if misconfigured, and host compromise on self-serve. Prefer Tailscale/direct when exposing serve. |
Local Keychain password injection is a strong design choice (model never sees secrets). Residual risks: browser session exposure, Composio OAuth scope, build-from-source supply chain, and always-on agent with real mail/calendar write paths. Keep approval rules strict; review triggers before enabling autopilot-style actions. |
High data sensitivity: terms explicitly allow use of Materials (including personal data) to train/fine-tune models; always-on access to screen, audio, location, email and messaging creates a large privacy surface. Users should read the August 2026 ToS carefully before granting broad device/app permissions. Managed service removes self-host RCE risk but concentrates trust in the vendor. |
Local-first by design (server owns all CLI processes). Main risks: exposing the WebSocket server off-machine without proper auth/network controls; whatever privileges the underlying agent CLIs have on the host; provider credential handling. Smaller general-purpose attack surface than OpenClaw because it is coding-agent focused and does not ship a skill marketplace. |
Moderate managed-SaaS profile: trust in vendor isolation, credential vault (write-only secrets), and OAuth to your AI/tool accounts. Separate browser profiles per teammate reduce cross-bot credential bleed vs single shared machine designs. Residual risks are prompt injection, over-permissioned integrations, and provider-side retention. FAQ: data is not training material. Not self-hosted, so no OpenClaw-style exposed-gateway RCE surface, but full trust is concentrated in Squad’s cloud and staff access controls. |
Local-first: agents and secrets stay on your machine; remote channel is end-to-end encrypted on paid plan. Main risks are host privileges of the coding CLIs, anything that exposes the desktop remotely while online, and provider credential handling. Smaller general-purpose attack surface than OpenClaw (coding-focused, no public skill registry). Proprietary binary — trust in the vendor’s release pipeline. |
Self-hosted control-plane risk profile: protect the dashboard and DB; connector OAuth tokens and per-agent permissions are high-value; misconfigured budgets/approvals can still burn tokens or take real actions via workers. No OpenClaw-style public skill malware surface of its own, but hired agents (especially OpenClaw) inherit their own risks. Audit log and governance are the main mitigations. |
High real-world identity surface: agents hold phone numbers, email inboxes, and payment wallets. Mitigations depend on permission scopes, payment limits, and approval gates. Prior Manus prompt-injection / email-borne issues (e.g. Salt Labs findings, patched via Meta bounty) show agent environments remain attack targets. Residual risks: social engineering of the agent’s identity, over-permissioned wallets, and trust in Manus/Meta isolation. Stronger independence than Muse (which acts as you) also means clearer blast radius if an agent is compromised. |
Commercial: high trust surface — agents touch GitHub, ads accounts, business email, and payments; review published ToS on revenue routing and data. Self-host inherits Claude Code host privileges and whatever credentials you inject. Independent reviews note low survival rate of generated companies and need to review everything before publish. Residual risks: over-autonomous outbound (email/ads), payment misrouting, and prompt injection into agent cycles. |
High-value surface: real wallets, signing, and social-prompted trades. Mitigations include pre-sign security screening and Club gates. Residual risks: social engineering via @mentions, prompt injection into trading instructions, smart-contract/protocol risk, and historical crypto-agent incidents (review Bankr security posts and wallet incident history). Never fund more than you can lose; prefer limits and read-only checks for new flows. |
High-trust surface: payments, connected accounts, phone calls, and social sharing of what the Pickle may say about you. Mitigations: spend confirmation, Link approval, share controls, no-training claims. Residual risks: social over-sharing, call transcription, cloud memory breach, and prompt injection into booking/pay flows. Fund and connect only what you’re willing to risk. |
Strong design: local SQLite, E2E phone path, host as sole authorization authority, approval cards. Residual risks: host compromise = full agent/project access; remote screen and `computer` tool expand blast radius; free relay is ciphertext-only but still a network path. Prefer Tailscale/direct when possible; keep Always-allow lists tight. |
Browser agent against real staging/prod-like apps: credential and data exposure in test environments, video/trace retention, and CI secrets. Mitigate with dedicated test accounts, non-prod data, and least-privilege roles. Residual risks: over-broad flows touching production, and third-party issue-tracker tokens. |
Local agents with real browser + optional saved logins expand blast radius. Mitigations: agents never see raw passwords, site-scoped fill, opt-in sign-in, approval gates. Residual risks: over-broad Always-allow, compromised machine, imported Chrome sessions, and prompt injection in agent browsers. Keep memory off until you need it; review Privacy settings. |
| Examples |
https://github.com/elie222/botdirectory.ai . Best references are xAI/Grok Bot official demos, botDirectory.ai, X/Twitter showcase threads from early beta users, and community recreations that mirror its ‘team of bots with computers’ pattern (see OpenMausBot and Rakazo repos). |
Official launch materials at about.fb.com and muse.ai / introducing.muse.ai (design and safety posts). Documented demos: back-to-school email/calendar/shopping, recipe reels → grocery list → order, travel booking, bill negotiation, form filling, party invites, selling a car. Connectors at launch include Google Workspace, Ticketmaster, OpenTable, Spotify, Apple Health, Meta apps. |
Official intro at openai.com/index/introducing-dots and chatgpt.com/features/dots; DevDay demos (calendar-aware dinner options, project ownership, voice); help.openai.com getting-started articles; third-party comparisons vs Grok Bot and Muse. |
https://github.com/OthmaneBlial/awesome-openclaw-examples (101 tested real-world usecases); https://github.com/openclaw/cookbook (official SDK recipes); https://github.com/hesamsheikh/awesome-openclaw-usecases (community life/automation cases); ClawHub skill registry + https://github.com/javimosch/open-claw-skills (thousands of curated skills); official showcase at openclaw/docs/start/showcase.md |
https://github.com/aliaihub/awesome-hermes-usecases (curated real-world cases with demos); official skills catalog in NousResearch/hermes-agent; https://github.com/frankxai/awesome-hermes-agent-skills; https://github.com/codesstar/hermes-skill-atlas; https://github.com/ChuckSRQ/awesome-hermes-skills; production blueprints at corpusiq.io/docs/hermes/agents |
No dedicated public use-case GitHub repo. Best sources are Meta AI help/docs inside WhatsApp/Instagram/Messenger, Meta AI web demos, and community prompt collections shared on X/Reddit. |
Official Manus demo walkthroughs and shareable replay links (slides, wide research, browser operator, spreadsheets, web-app building); community prompt/template collections such as ‘Manus AI Prompts: 15 Agent Templates’. |
Official OpenAI cookbook / examples repos (openai/openai-cookbook), Custom GPT store and Actions templates, ChatGPT computer-use / agent demos in OpenAI docs and product blog. |
Anthropic official computer-use and tool-use cookbooks / docs; Claude Projects and Artifacts demos; community repos that wrap Claude computer-use. |
Official Lindy template library at lindy.ai/templates (Gmail/Slack alerts, lead enrichment, meeting assistants, support triage, etc.); large collections of ready-made agents in tutorial videos. |
Primary examples live in the project’s own repository and docs (sandbox + desktop-control demos). Community use-cases still sparse compared with OpenClaw/Hermes. |
https://github.com/elie222/rakazo (main repo + demo + self-host docs). Early community examples focus on the built-in bot roles shown on rakazo.com (Chief of Staff, Bug Triage, Expense Manager, etc.). |
openmausbot.com (home, pricing, /pro Cloud); docs.openmausbot.com; GitHub milind-soni/OpenMausBot; blog posts (Grok Bot vs OpenMausBot, which agent to use, memory notebook); App Store / download pages for desktop and mobile. |
github.com/composio-community/open-dot README (browser, Keychain, Composio, rules, voice, schedules); community write-ups comparing it to ChatGPT Dots on Mac. |
No public open-source repo (closed product). Best material is user reports and demos on X (booking flights/hotels, shopping overnight, negotiating with vendors on WhatsApp, finding in-network doctors + filling paperwork, lowering bills, etc.) and the product site instinct.co. Frequently compared directly with Grok Bot and OpenClaw as the consumer-friendly version of the same pattern. |
https://github.com/pingdotgg/t3code (main repo, docs, AGENTS.md); official site t3.codes; install docs and provider matrix in the repo; community forks that expand provider support (e.g. ACP editions) |
Official docs and playbooks at squad.so/resources/docs; product marketing and Grok Bot comparison/examples content on squad.so/resources (e.g. grok-bot-examples, mission-control comparisons). Lead proposes roster after business interview; typical lanes: support, content, ops, CFO-style review with draft-before-send rules. |
Product site enjoy.dev (demo, positioning for solo builders). Workflows: plan with one agent, build with another; multi-project management; local preview/API servers from the workspace; morning check-ins and release readiness flows. |
https://github.com/paperclipai/paperclip (core); paperclipai/companies (templates); docs at docs.paperclip.ing; blog demos of hiring CEO → strategy → engineers/marketers; Connectors launch (per-role Gmail/GitHub access); comparisons positioning Paperclip as company OS over OpenClaw/Claude Code employees. |
Official site cue.im (booking/travel, shopping, admin, money, daily life, work demos); Manus 2.0 launch posts; early-user writeups comparing Cue vs Grok Bot vs Muse (identity vs shared-login models); QR-to-agent for merchants. |
polsia.com live activity / company feed; GitHub PolsiaAI/Polsia (9-agent Docker stack); reviews documenting idea → provision → nightly cycle; founder claims of 1,000+ companies run autonomously (active share much lower in third-party counts). |
docs.bankr.bot (agent overview, trading, self-sustaining agent guide); bankr.bot terminal and leaderboard; GitHub BankrBot/skills; CLI examples (swap, launch, fees); social execution from X/Telegram; OpenClaw skill install path. |
App Store listing “Pickle: Raise your AI”; pickle.com privacy/terms (own computer, phone calls, Link payments); product copy on levels, energy, and neighborhood Pickles. |
codync.dev; github.com/leepokai/Codync (README, architecture, bot-collaboration docs); App Store “Codync”; Product Hunt positioning as open Grok Bot/Muse/Dots alternative. |
runcofactor.com product demos (multi-role billing flows, video reports); docs.runcofactor.com (concepts, quickstart); npm `@runcofactor/cli`; founder positioning around regression as the gate for agent-speed shipping. |
openswarm.com; Product Hunt “OpenSwarm”; GitHub openswarm-ai/openswarm releases (1.8.x: panels, rebuilt browser agent, Sonnet 5.5); demo flows (parallel food research, app-on-request, Problem Validator across Reddit/X/HN). |
| QUICK POSITIONING |
| Quick Positioning |
The original high-polish, fully managed 'AI teammates with their own computers' product from xAI. Highest convenience and integration quality, but locked to Grok models, expensive, and you do not own the runtime or the data plane. |
Meta’s mass-market personal agent: Secure VM + browser + approvals, WhatsApp/app-native, free-to-start. Closest big-tech answer to Instinct and OpenClaw for everyday consumers — stronger distribution and polish than open-source stacks, weaker ownership and model choice than self-hosted options, and full trust concentration in Meta. |
OpenAI’s always-on personal/work agent with its own cloud computer — the direct ChatGPT answer to Grok Bot and Muse. One primary dot (not a multi-bot roster yet), deep plugin ecosystem, Slack/Teams native. Best if you already live in ChatGPT Pro/Business; weaker on ownership and model choice than self-hosted stacks. |
The most popular open-source multi-channel agent gateway. Excels at reach (25+ messaging apps) and a huge community skill library. Best when you want one agent (or swarm) living inside the chat apps you already use. |
The self-improving open-source agent from Nous Research. Strongest on learning loops (skills that compound over time), model flexibility, and cheap long-running instances. Ideal when the agent should get better the more you use it. |
The ubiquitous free assistant already living inside WhatsApp, Instagram, and Messenger. Lowest friction and zero cost, but weakest on true computer-use, ownership, and deep agent autonomy compared with the dedicated bot platforms. |
Cloud-native autonomous task runner with strong browser/computer-use. Best for one-shot or multi-step jobs you want done in a real sandbox without self-hosting. Less focused on persistent personal memory or multi-channel presence. |
OpenAI’s managed agentic layer on top of ChatGPT. Excellent computer-use and tool calling inside the OpenAI ecosystem, but model-locked and cloud-only. Best if you already live in ChatGPT and want the least operational overhead. |
Anthropic’s computer-use and agentic features. Strongest safety posture and high-quality reasoning inside the Claude family. Good managed alternative when you want reliable desktop/browser control without self-hosting, but still model-locked and cloud-only. |
Business-oriented managed agent platform focused on email, calendar, CRM, and recurring workflows. Excellent for personal or team delegation of knowledge work; weaker on full Linux-desktop computer-use compared with Grok Bot-style products. |
Lightweight open-source focus on isolated Linux desktops per agent. Good middle ground for users who want real computer-use sandboxes without the full multi-channel gateway complexity of OpenClaw or the learning-loop emphasis of Hermes. |
One of the closest open-source spiritual successors to Grok Bot: persistent bots that each get a real computer, can sign into tools, run Markdown routines, and hand work between peers — with full ownership, model freedom, and no vendor lock-in. Still early beta. |
Open-source Grok Bot–style chat app of bots on the CLIs you already pay for. Free local app remains the core; **Pro ($49/mo)** and sibling Cloud plans close the classic gap — always-on workspace, cloud computers, and scheduled work with the lid closed — without locking models or reselling tokens. Best if you want multi-model teams and ownership; pick pure Grok Bot/Dots/Muse if you want zero ops and one vendor stack. |
Open-source, Mac-local answer to OpenAI Dots: named agents with their own browsers, approval rules, and app connectors without a Pro subscription. Stronger on ownership and model choice than Dots/Muse; weaker on true always-on (app must stay open) and maturity vs OpenClaw/Hermes. Best if you want Dots-like UX on hardware you control. |
“OpenClaw for normal people.” Fully managed personal agent with iMessage/phone as the interface, extreme proactivity, and real-world task completion (bookings, shopping, admin, calls). Strongest simplicity and everyday-life focus; weakest on ownership, model choice, and transparency of data use. |
Open-source control plane / GUI for coding agents. Best-in-class mobile + desktop + web surface that drives Claude Code, Codex, Cursor, Grok Build and OpenCode with your existing subs. Not a general personal-life agent (Instinct/Grok Bot/OpenClaw territory) — it is the polished harness for parallel coding work, git worktrees, and one-click PRs. |
Managed multi-model AI squad with a Lead + specialists, shared task board, and 24/7 schedules — on the AI plans you already pay for. Closest commercial competitor to ‘Grok Bot as a multi-provider team operation’: stronger model freedom and ops dashboard than Grok Bot, weaker ownership than self-hosted OpenClaw/Hermes/Rakazo/OpenMausBot. Best when you want a standing business team without running servers. |
Polished desktop workspace for Claude Code / Codex / Grok Build — the non-terminal way to run pro coding agents and manage real software projects. Closest peers are T3 Code (more open, multi-surface control plane) and pure CLI agents. Not a personal-life / multi-channel agent like Instinct, Muse, or OpenClaw. |
Open-source multi-agent company OS: org charts, budgets, goals, and tickets over BYO agents. Complements OpenClaw/Hermes/Claude Code rather than replacing them — Paperclip is the management layer, not the hands. Best when you want many specialized agents under one accountable board instead of a single personal assistant or a pure coding workspace (T3 Code / Enjoy). |
Personal agents with *their own* phone, email, wallet, and computer — not just acting inside your logins. Closest peer to Muse and Instinct for consumer life-admin, with a sharper ‘independent identity’ bet than Grok Bot’s work-teammate model. Managed only; early access free with invite. |
Autonomous AI company runner: specialized agents that plan, ship code, market, and support a business on a schedule. Closer to Paperclip’s “company OS” ambition than to a personal assistant (Muse/Cue/Dots) or coding workspace (T3 Code/Enjoy). Best for solo founders willing to review aggressively; weak if you need model freedom, full ownership, or high-confidence product-market fit before shipping. |
Crypto-first agent runtime: wallet + natural-language DeFi + self-funding token flywheel, reachable from social feeds and a terminal. Not a general life assistant (Muse/Cue/Dots) or coding workspace (T3 Code/Enjoy) — the category leader for conversational on-chain trading and agent treasuries. Complements OpenClaw via the Bankr skill rather than replacing it. |
Consumer life agent with character, memory, and a real computer — book/order/pay/call with human yes on spend. Stronger on companionship and social Pickle-to-Pickle than on work multi-agent or self-host ownership. Best if you want Muse-like daily help in a playful raise-your-AI form; weak if you need desktop computer-use, model choice, or open-source control (use OpenClaw / pickle-bot for that). |
Open-source bot UI for the coding agents you already pay for — Grok Bot / Muse-style named teammates, group chat, and phone approvals without a new subscription or cloud computer. Best for developers who live in Claude Code/Codex/Cursor and want mobile delegation; not a general life assistant (Muse/Pickle) or crypto runtime (Bankr). |
Vertical agent for QA: real-browser, self-healing regression so coding agents can ship faster without silent breakage. Complements Codync/T3 Code/Claude Code rather than replacing Muse/Dots/Grok Bot. Best for teams drowning in agent-generated PRs; not a personal assistant or general computer-use teammate. |
Parallel-agent desktop OS on *your* machine: many browsers and specialists on one canvas, not one cloud teammate. Closest peers are OpenClaw / OpenMausBot / Codync for local control; differs from Grok Bot / Muse / Dots by staying on-device and swarm-first. Best when you want to orchestrate dozens of steps in parallel; less ideal if you need laptop-closed always-on cloud workers. |