Open Source Manus Alternatives

OpenClaw is an open source AI assistant that runs on your own computer and meets you in the channels you already use, from Discord and Slack to iMessage, Telegram and WhatsApp, with native apps for macOS, iOS, Android, Windows and Linux. It removes the need to sit in a vendor's chat window to reach an assistant.

A single Gateway acts as the local control plane for sessions, tools, events and channel connections, and the Control UI, the CLI and the TUI all connect to it. The same process serves one person on a laptop or a whole team, and only the configuration differs.

The pieces that matter for anyone weighing a self-hosted assistant.

• Local state: memory, credentials and session data stay on your hardware, and the project itself checks only for a daily version update.
• Swappable models: hosted and local providers plug in, so Claude, Codex or a local model becomes a configuration choice.
• Channels: WhatsApp, Telegram, Slack, Discord, Google Chat, Signal and iMessage all reach the same assistant.
• Companion apps: platform nodes add voice, canvas, camera, screen and device-local actions.
• Tools, skills and plugins: three extension points widen what the assistant can actually do.

The installer covers macOS, Linux and Windows and provisions a Node.js runtime when one is missing, with an npm package for people who manage Node themselves. Treat inbound messages as untrusted, since tools run on the host unless you configure sandboxing. Stewardship sits with an independent nonprofit foundation, and there is no paid tier or hosted service.

Hermes Agent is built around a learning loop. It creates skills from experience, improves them while using them, searches its own past conversations and builds a model of the person it works for across sessions.

It is not bound to a laptop. One gateway process serves Telegram, Discord, Slack, WhatsApp, Signal and the command line at once, with voice memo transcription and conversation continuity between them, so the agent can keep working on a cloud machine while you talk to it from a phone.

The project describes its own capabilities in five areas.

• Terminal interface: a full TUI with multiline editing, slash-command autocomplete, history, interrupt and redirect, and streaming tool output.
• Memory and recall: agent-curated memory with periodic nudges, full-text session search with summarization, and dialectic user modeling.
• Scheduled automations: a built-in cron scheduler runs daily reports, nightly backups or weekly audits unattended and delivers them to any platform.
• Delegation: isolated subagents handle parallel workstreams, and Python scripts call tools over RPC to collapse multi-step pipelines.
• Seven terminal backends: local, Docker, SSH, Singularity, Modal, Daytona and Vercel Sandbox, two of which hibernate when idle and wake on demand.

Any model works, whether through Nous Portal, OpenRouter, OpenAI or your own endpoint, and switching takes one command rather than a code change. Install scripts cover Linux, macOS, WSL2, Termux and native Windows, pulling in Python, Node.js and the other dependencies. It runs on a cheap VPS or a GPU cluster, suiting anyone who wants an agent that stays awake between sessions.

NanoClaw came out of a refusal. Its author would not hand complex software he did not understand full access to his life, so each agent here runs in its own Linux container and sees only what you explicitly mount, rather than sitting behind application-level allowlists in one shared process.

A single Node host acts as the router. A message arrives from a channel, gets written to a per-session SQLite file, and wakes the container; the agent writes back to a second SQLite file that the host polls and delivers. Two files per session with exactly one writer each removes any need for IPC or stdin piping.

The project takes a firm line on how it grows.

• Skills over features: channel adapters and alternative model providers live on separate branches, copied into your fork on demand.
• No configuration files: you change behavior by asking Claude Code to edit the code, which is small enough to review.
• Multi-channel: WhatsApp, Telegram, Discord, Slack, Teams, iMessage, Matrix, Google Chat, Webex, Linear, GitHub and email are all installable.
• Agent templates: a reusable bundle of instructions, tools and skills stamps out a ready-to-run agent carrying no secrets.
• Nothing phones home: only anonymous setup diagnostics leave the machine, and one environment variable turns those off.

One shell script installs Node, pnpm and Docker if missing, registers your credential, builds the agent container and pairs your first channel. It needs macOS or Linux, Windows through WSL2, Node 22 and Docker.

Kortix, the project developed in the Suna repository, treats a company as something you can clone. The agents, the skills they share, the company memory and every connector are files in a git repo, versioned and diffable, not configuration trapped inside somebody else's product.

Work happens on cloud computers. Each session gets a disposable, isolated Linux sandbox on its own branch, where the agent can install, run and break anything, and only what it commits survives. Nothing reaches the main branch until you approve a change request, so the company improves one reviewed change at a time. Thousands of sandboxes can run in parallel.

The pieces you manage are few, and each one is a file you can read.

• Agents: OpenCode agents with scoped tool access, markdown at the baseline, one per role or task, able to rewrite themselves.
• Skills: reusable know how that encodes how your company does a job, written once and shared into every session.
• Connectors: more than 3,000 apps in a click, plus MCP, OpenAPI, GraphQL and raw HTTP, with credentials brokered server side and never entering the sandbox.
• Channels and triggers: a Slack app starts sessions where your team works, while cron schedules and signed webhooks start them automatically.
• Secrets: encrypted at rest, granted per agent, and injected into the sandbox as real environment values at runtime.

Any provider works with your own API keys. Kortix runs from Docker images on a laptop, a VPS, your own VPC or an on-prem network, and the CLI switches between your hosts and the cloud.

Eigent packages an AI workforce into a desktop application, where agents build, manage and run the multi-step workflows you would otherwise walk through by hand. It removes the gap between talking to a single model and having work actually carried out on your machine.

The app is built on CAMEL-AI's multi-agent framework, with a FastAPI backend and an Electron and React front end. You start with one focused agent for direct tasks, or scale to a workforce of specialised agents that divide the job and execute in parallel.

The feature set suits people who want agents close to their files rather than in someone else's cloud.

• Local deployment: a standalone mode with a local backend and local inference through vLLM, Ollama or LM Studio.
• Model agnostic: connect cloud APIs, enterprise gateways or local models without committing to one vendor.
• MCP integration: agents pick up tools through MCP servers, alongside built-in browser and terminal toolkits.
• Automation: recurring workflows run on a schedule, so tasks continue when you step away.
• Enterprise options: SSO, access control and custom development for organizations that ask for them.

The cloud-connected quick start needs Node.js 18 to 22 and npm, and it registers an account against Eigent's services. A separate guide covers the fully standalone local install, and a managed cloud version exists for teams that prefer to host nothing at all.

Rakazo runs persistent AI bots that keep their own conversations, memory, routines and history, rather than forgetting everything when a chat window closes. It is available on the web, as an Electron desktop app and through an Expo mobile app, and the complete stack can run locally. The project is in beta.

The codebase is TypeScript throughout, with React 19, Vite and Tailwind on the front end, Hono and oRPC on the API, PostgreSQL with Prisma for storage, Better Auth for accounts and Graphile Worker for background jobs. Model credentials stay yours, brought in through Pi.

Bots are given real machines and real tools to work with.

• Computers: shared team computers and isolated private ones, backed by Docker, E2B, Daytona, Box or a trusted local machine.
• Access: browser, terminal, file and graphical desktop control from inside a session.
• Delegation: bots hand work to peer bots or to short-lived subagents.
• Voice mode: spoken replies, dictation and calling a bot, using your own ElevenLabs, OpenAI, Cartesia or Fish Audio key.
• Integrations: Composio or Pipedream Connect catalogs, plus user-installed remote MCP servers, Treg endpoints and OpenAPI documents.

Installing the published images needs only Docker Engine, the Compose plugin, curl and OpenSSL; a script writes an environment file with random secrets and starts everything. Running the backend on a server keeps bots working while your laptop is shut. Connector credentials are encrypted on the server and never returned by the API.