Open Source Msty Claw Alternatives

OpenClaw is a personal AI assistant built to take action. It doesn't just answer questions. It clears your inbox, sends emails, manages your calendar, and handles tasks like flight check-ins, all triggered through chat apps you already use every day.

The core idea is that you shouldn't need a new app to talk to your assistant. OpenClaw works through WhatsApp, Telegram, Discord, Slack, Signal, and iMessage, so you interact with it wherever you already spend time. No dashboard to open, no new habit to build.

It connects to a wide range of services out of the box:

• Email and calendar via Gmail and similar tools, handling real actions, not just summaries
• AI models including Claude and GPT, so you can route requests through your preferred backend
• Productivity tools like Obsidian and GitHub for note-taking and code workflows
• Smart home and media through Philips Hue and Spotify
• Social and browser via Twitter and direct browser control

What sets it apart from most chat-based AI tools is the action layer. Many assistants can tell you what to do. OpenClaw does it. The integrations aren't read-only; it can send, create, update, and automate across connected services.

The project is open source and self-hostable, which matters if you're handing an assistant access to your email and calendar. You control where it runs and what it can reach. A companion menubar app is available for macOS users who want quick access without switching windows.

It's an independent project, not affiliated with Anthropic or any of the AI providers it connects to. That independence shows in the breadth of integrations rather than a walled ecosystem.

Hermes Agent is a desktop AI agent built by Nous Research that runs natively on macOS, Windows, and Linux. It's designed for people who want a single agent that works across their communication tools, handles recurring tasks, and actually remembers what it's done before.

The core idea is persistence. Most agents start fresh every session. Hermes maintains memory across conversations, auto-generates skills from past interactions, and builds up context about your projects over time. You don't have to re-explain things.

Where it connects:

• Telegram, Discord, Slack, WhatsApp, Signal, and email are all supported natively, so the agent meets you where you already work
• A CLI interface is also available for terminal-first workflows

What it can do:

• Natural-language scheduling for reports, backups, and briefings that run unattended
• Web search and browser automation with vision, image generation, and text-to-speech
• Subagents that run in isolated conversations with their own terminals and Python RPC scripts, useful for parallel pipelines without ballooning context costs
• Multi-model reasoning with access to 300+ models through the Nous Portal

Sandboxing is a genuine differentiator. Five execution backends (local, Docker, SSH, Singularity, and Modal) give you control over where code actually runs, with container hardening and namespace isolation. That matters if you're running automated tasks or untrusted scripts.

For teams or individuals already using LobeChat or similar multi-surface chat interfaces, Hermes takes a different angle: it's less about chat UI and more about an agent that operates autonomously across surfaces. Think of it as closer to an AgentOS approach, where the agent itself is the persistent layer.

It's free to use under the MIT license, with paid tiers through the Nous Portal for higher model access and monthly credits.

NanoClaw is a self-hosted personal AI agent built for individuals who want full control over their AI assistant. It connects to messaging apps including WhatsApp, Telegram, Discord, Slack, Microsoft Teams, iMessage, Matrix, Google Chat, Webex, WeChat, and email, then routes every conversation through isolated Docker containers. The codebase is intentionally small: 132 source files, roughly 17,500 lines of code, and fewer than 10 dependencies. You can read the whole thing in an afternoon.

It positions itself as a lightweight alternative to OpenClaw, which ships 3,680 source files and 70 dependencies. That size difference isn't cosmetic. It shapes whether you can audit what your agent actually does, customize it without fear, and trust its security model.

Security is structural, not policy-based. Each agent group runs in its own Linux container with its own filesystem. It can only see directories you explicitly mount. Credentials never enter the container at all. Outbound API requests route through OneCLI's Agent Vault, which injects authentication at the proxy level and enforces per-agent rate limits and policies.

Key capabilities:

• Multi-channel messaging – WhatsApp, Telegram, Slack, Discord, Teams, iMessage, Matrix, and more, installed on demand with /add-<channel> skills
• Flexible agent wiring – give each channel its own isolated agent, share one agent across channels for unified memory, or fold channels into a shared session
• Per-agent workspaces – each agent group has its own memory, its own CLAUDE.md, and its own container boundary
• Scheduled tasks – recurring jobs that run Claude and message you back (morning briefings, weekly reviews)
• Multiple AI providers – runs Claude Code natively via the Claude Agent SDK; drop-in options for OpenAI Codex, OpenRouter, Google, DeepSeek, and local models via Ollama
• Skills over features – install only the adapters you need; nothing is bundled that you didn't ask for

The architecture is a single Node.js host process that routes inbound messages through an entity model, writes to SQLite, and wakes per-session containers. No microservices, no message brokers, no shared memory across agent boundaries.

NanoClaw is MIT-licensed and designed to be forked. The philosophy is that your personal AI agent should be working software shaped to your exact needs, not a generic framework you configure around.

Most AI assistants are a seat you rent on someone else's infrastructure. ZeroClaw runs as a single native binary on your own machine, using your own API keys or fully local models like Ollama. No cloud seat, no subscription, no ZeroClaw server in the middle.

The binary is built in Rust and starts in under 20ms. It uses less memory than a browser tab and runs on everything from a workstation to a Raspberry Pi, including ARM and x86. There's no Node, JVM, or Python environment to install.

What it connects to:

• 70+ LLM providers: local options like LM Studio, llama.cpp, vLLM, and LocalAI, plus hosted providers including Anthropic, OpenAI, Google Gemini, Amazon Bedrock, Mistral, Groq, and any OpenAI-compatible endpoint
• 30+ channels: Telegram, Discord, WhatsApp, Slack, Signal, iMessage, Matrix, email, IRC, Bluesky, Reddit, Nostr, Notion, webhooks, and more
• Hardware: GPIO on Raspberry Pi, STM32, Arduino, and ESP32

Security is the default posture, not an add-on.

• Supervised autonomy: medium-risk actions require your approval before they run; high-risk ones are blocked outright
• OS-level sandboxes: Landlock, Bubblewrap, Seatbelt, or Docker contain what the agent can touch, enforced by the kernel rather than a prompt
• Command allowlists: explicit workspace scoping decides what runs and where
• Tool receipts: every successful tool call can be stamped with an HMAC-SHA256 tag the model cannot forge, making fabricated runs or invented results detectable

YOLO mode exists for trusted dev environments and is strictly opt-in.

The agent supports multiple named agents running from a single daemon, each isolated. Skills package repeatable tasks with their tools. Scheduled jobs, webhook triggers, and channel events all run through the same agent loop inside the same sandbox and allowlists you've scoped. A2A discovery lets agents describe and find one another through the gateway.

With a local model, nothing leaves your machine at all. With a hosted provider, only your prompts go to the provider you chose, using your own key. Dual-licensed MIT OR Apache-2.0.

Kortix is a platform for running AI agents across an entire company, where the whole setup lives in a single git repo you own. Agents, skills, memory, connectors, triggers, and permissions are all plain files. You can grep the company, diff any change, and roll anything back. No settings locked in someone else's database.

It fits teams that want AI agents doing real, multi-step work across sales, engineering, finance, marketing, and ops, not just answering questions. Agents start from Slack, MS Teams, the web, a CLI, a cron schedule, or a signed webhook. Work lands back in the repo as a change request you read as a diff before it merges.

The platform is built in six layers that work together:

• Git repo as the source of truth. kortix.yaml declares the machine image, connectors, and triggers. Agents and skills are markdown files. Memory accumulates as files over time.
• Connectors. 3,000+ app integrations plus MCP, OpenAPI, GraphQL, and raw HTTP. Credentials are brokered server-side and never reach the agent's machine. Each tool call can be set to allow, ask, or block, down to the specific arguments passed.
• Model-agnostic runtime. Pick any model per agent, per session, or per message. Bring your own API keys, use a ChatGPT subscription you already pay for, or point it at any OpenAI-compatible endpoint.
• Agent harness powered by OpenCode. Turns a model into an agent that plans, uses tools, and finishes multi-step runs. Permissions are set per tool in the agent file, so a git push can be blocked until a human reviews the change request.
• Isolated sandboxes. Each session boots its own Linux machine with the repo and tools already loaded. Thousands run in parallel with no crossover. Only commits survive.
• Unified control plane. Web, Slack, mobile, CLI, and API all start the same session type. Cron and webhooks start sessions with no human involved.

Practical examples from the source: an engineering agent reads error logs each morning, reproduces the top failure on its own machine, patches it, and opens a pull request. A finance agent reconciles the ledger, chases missing receipts, and closes the month with the variance explained. A data science agent queries the warehouse on a schedule and posts the chart to Slack before the team wakes up.

Kortix is self-hostable, VPC-deployable, or available as managed cloud. It sits in the AI coding agent orchestrators space but extends well beyond code, covering any business function that can be described as a repeatable job.