| OWNERSHIP |
| License |
Proprietary (xAI) |
Proprietary (Meta) |
MIT |
MIT |
Proprietary (Meta) |
Proprietary |
Proprietary (OpenAI) |
Proprietary (Anthropic) |
Proprietary |
Open-source (check repo for exact; community self-hosted) |
Apache-2.0 |
MIT (notes also reference Apache-2.0 adoption) |
Proprietary (Spear Street Technology, Inc.) |
MIT |
Proprietary (managed SaaS; formerly MissionControlHQ) |
Proprietary (desktop app; releases via GitHub atmoio/enjoy-releases) |
MIT (open source) |
| Hosting |
Managed cloud by xAI |
Managed cloud (Meta); Muse Secure VM per user |
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 |
Local-first (127.0.0.1 harness); optional cloud Box desktops, Local VM, or BYO VPS via SSH + Cua containers |
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 |
| 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 |
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 |
Per-bot computer: cloud Linux desktop (live preview), isolated Local VM, host control (macOS + Ubuntu GNOME beta), or self-hosted VPS container |
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 |
| 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 |
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) |
User-owned (~/.openmausbot workspaces, MEMORY.md, transcripts, keys) |
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) |
| 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 |
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 |
Explicit Allow/Deny cards in chat; temporary human takeover; agents can request human operation |
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 |
| 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 |
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 picker; runs on Claude, Codex, Grok, Cursor Agent CLI, Gemini, etc. using existing logins/subscriptions |
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 |
| 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 |
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 |
Computer use (Cua), browser (embedded Chromium/CDP), files, 500+ apps via Composio, MCP plugins |
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 |
| MEMORY AND SKILLS |
| Memory |
Persistent per-bot conversation + memory |
Persistent across conversations; learns preferences, reflects on goals, proactive suggestions from context |
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 |
Per-bot workspace + file-based (MEMORY.md into prompt + topic files); plain Markdown editable by user |
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 |
| 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 |
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) |
Personality + model per bot; shareable teams/crews; MCP plugins; routines early/coming |
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 |
| 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 |
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 |
Bot-to-bot communication; exportable/shareable teams |
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 |
| Channels |
Native app / messaging-style interface; multi-platform clients |
Dedicated Muse app (iOS/Android), muse.ai web, WhatsApp; AI glasses coming soon |
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) |
Native desktop app (macOS, Windows, Ubuntu); phone companion (LAN/tailnet); voice (macOS STT + ElevenLabs) |
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) |
| 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 |
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 |
Early / limited native scheduling (routines noted as coming) |
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 |
| 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. |
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 signed desktop app (or build); requires underlying agent CLIs already installed & authenticated. Desktop app embeds Chromium for in-app browser use — no separate Chrome/Safari install required for bot browsing. External links open in the system default browser. |
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. |
| Ops burden |
Very low (fully managed) |
None (fully managed consumer product) |
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–medium for pure local; higher with BYO VPS or multiple cloud boxes |
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 |
| 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 |
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 |
Free forever; unlimited bots; only existing AI subscriptions / optional voice & sandbox costs |
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 |
| 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. |
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. |
Designed local-first (harness binds 127.0.0.1 only, no auth by design — trusts the local user). Main risks: anything that exposes the harness off-machine, broker bypasses for risky actions, secret echo in logs/API, or shell injection when spawning CLIs. Host-control and BYO-VPS modes enlarge the blast radius. |
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. |
| 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. |
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.). |
https://github.com/milind-soni/OpenMausBot (main repo + docs). Product site and shareable team-export feature are the primary use-case surfaces. Community examples revolve around multi-bot teams and Composio-connected workflows. |
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. |
| 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. |
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. |
Purest open-source 'Grok Bot shape' clone: messaging-style roster of named bots, each with personality, model, memory, computer, and tools. Biggest differentiator is BYO agent CLIs (reuses Claude/Codex/Grok/Cursor subscriptions you already pay for). Local-first with strong approval cards and editable Markdown memory. |
“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). |