Ad
Learn more

Open Source Hermes Agent Alternatives

A curated collection of the 15 best open source alternatives to Hermes Agent.

The best open source alternative to Hermes Agent is OpenClaw. If that doesn't suit you, we've compiled a ranked list of other open source Hermes Agent alternatives to help you find a suitable replacement. Other interesting open source alternatives to Hermes Agent are: AutoGPT, nanobot, NanoClaw, and ZeroClaw.

Hermes Agent alternatives are mainly AI Personal Assistants but may also be AI Agent Platforms. Browse these if you want a narrower list of alternatives or looking for a specific functionality of Hermes Agent.

Written by Piotr Kulpinski

A personal AI assistant that connects to your existing chat apps and handles real tasks like email, calendar, and flight check-ins on your behalf.

Screenshot of the OpenClaw website

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.

Platform for building, deploying, and running AI agents that automate repeatable digital work across research, outreach, content, and support without writing code.

Screenshot of the AutoGPT website

AutoGPT is an AI agent platform for people who want to hand off recurring work entirely, not just get help with a single task. You describe the outcome you want, and an agent plans and executes every step: pulling data, calling AI models, updating spreadsheets, sending messages, and looping back on a schedule. It's built for the kind of work that comes back every day or every week.

There are four ways to interact with the platform:

  • AutoPilot lets you describe a job in plain English and builds the agent for you inside the conversation, no flowcharts or prompt engineering required.
  • Visual Builder gives you a drag-and-drop canvas of blocks when you need exact control over branching, looping, and routing logic.
  • Dashboard shows every agent's status, run history, and spend in one place, with alerts when an agent needs a decision from you.
  • Marketplace offers ready-made agents from AutoGPT and the community, browsable without an account and deployable in one click.

On the integration side, the platform ships with dozens of AI models already connected (no API keys needed) and supports services like Gmail, Slack, Google Sheets, Notion, HubSpot, GitHub, and Airtable. Agents can handle chat, image generation, video, transcription, OCR, and more across 45+ platforms.

Common uses include morning briefings assembled from earnings and headlines, prospect research before sales calls, overnight campaign drafts, support ticket triage, and competitor monitoring that only pings you when something actually changes.

AutoGPT is fully open source. Self-hosting is free: you bring your own model API keys and infrastructure and get the same builder and agent runtime as the cloud. The hosted cloud removes the ops burden and covers model usage through a subscription. Teams often prototype in the cloud and move sensitive workloads on-prem later.

For teams that want a visual workflow automation approach rather than agent-based logic, tools like ByteChef or Automa take a different angle. If you're looking for an agent-first experience with a different focus, Eigent is worth comparing. AutoGPT's sweet spot is repeatable, multi-step work you can describe clearly enough to hand to a capable assistant.

Lightweight, self-hosted AI agent that runs in a web UI, terminal, or chat app, handling long-running workflows with controlled token budgets.

Screenshot of the nanobot website

nanobot is a minimal, self-hosted AI agent designed to run wherever you work: a web UI, your terminal, or a chat interface. It's built for people who want a personal AI agent they control, without the overhead of bloated frameworks or cloud-locked platforms.

The core design philosophy is lean execution. Rather than consuming tokens without restraint, nanobot applies sensible context management and explicit token budgets, so your costs stay predictable. That matters especially for long-horizon tasks, where the agent needs to sustain coherent reasoning across tens or even hundreds of steps without losing the thread.

Key capabilities:

  • Multi-surface operation: runs in a browser-based web UI, a terminal, or directly inside chat apps, so you're not locked into one interface
  • Long-running workflows: maintains steady execution across complex, multi-step tasks without context drift
  • Token budgeting: built-in controls keep spending predictable, unlike agents that leave cost management entirely to the user
  • Embeddable runtime kernel: the agent core is portable, so you can drop it into a business workflow or a personal automation setup without rewiring everything around it
  • Self-hosted: your data stays on your infrastructure; no third-party service holds your conversations or task history

Compared to heavier agent frameworks or fully managed platforms like Agenta, nanobot stays deliberately small. The codebase is compact, the runtime is portable, and the architecture doesn't assume you want a full orchestration platform. It suits developers and technically minded individuals who want an agent they can embed, extend, or just run locally without a lot of ceremony.

It supports automation tasks, developer integrations, and conversational use cases through the same core runtime. The MIT license means you can adapt it freely for personal or commercial use.

Self-hosted AI agent that connects to WhatsApp, Telegram, Slack, and a dozen more messaging apps, running each agent in an isolated Docker container with credential injection via a secure vault.

Screenshot of the NanoClaw website

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.

A single Rust binary that runs a personal AI agent on your own hardware, connecting to 70+ LLM providers and 30+ messaging channels with built-in sandboxing and cryptographic tool receipts.

Screenshot of the ZeroClaw website

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.

Run a team of AI agents locally on your own API keys and subscriptions, with scheduled tasks, computer use, and Gmail, GitHub and Slack integrations.

Screenshot of the MausBot website

MausBot is a local-first Grok Bot alternative that lets you run a team of AI agents from a familiar chat interface. Each bot gets its own model, its own computer, and access to your connected apps. They work in parallel, come back when something needs your attention, and never proxy your credentials through a third party.

It runs on Mac, Windows, and Linux under Apache 2.0. Your transcripts, keys, and events stay in a local folder on your own disk. Local-first isn't a setting; it's the default.

Key capabilities:

  • Model per bot. Assign Claude, Codex, or other models to individual bots and switch mid-conversation.
  • Computer use. Each bot gets a desktop it can see and click, either a cloud desktop from a provider you connect or your local machine directly.
  • Scheduled tasks. Inbox sweeps, weekly reports, competitor watches, PR reviews, and support triage all run on a calendar you define.
  • Connected apps. Gmail, Slack, GitHub, Notion, Linear, and hundreds more via Composio. Authenticate once and every bot on the team can use them.
  • Voice. Hit call and the bot hears you, narrates its work, and asks for approvals out loud.
  • Playbooks. A whole team, its routines, and its app connections ship as a single Markdown file. Connections stay off until you approve them.
  • Manage bots like contacts. Pin, duplicate, mark unread, hide, or delete. The interface is a messaging app, not a dashboard.

For teams that want bots running around the clock without leaving a laptop on, Cloud plans add always-on workspaces with scheduled tasks and voice included. You still bring your own Claude or ChatGPT account; MausBot never sits between you and the model provider.

Compared to other AI chat interfaces, MausBot is built specifically for multi-agent workflows where each agent has persistent tasks, tool access, and its own compute rather than just a shared conversation window.

Desktop app for teams to run AI agents across 50+ LLMs, share skills and MCP servers org-wide, and automate browser tasks with your own keys.

Screenshot of the OpenWork website

OpenWork is a desktop app (and browser-based workspace) that lets individuals and teams run AI agents against their own files, tools, and data. It's built on OpenCode and positions itself as an open alternative to Claude Cowork, supporting 50+ LLMs from providers like OpenAI, Anthropic, Google, Mistral, and local models, rather than locking you to a single vendor.

The core idea: bring your own API keys, wire in the tools your team already uses, and package everything into reusable setups that anyone can import in one click. No terminal required.

Key capabilities:

  • Multi-model support – switch between OpenAI, Anthropic, Gemini, Bedrock, Azure AI Foundry, Mistral, OpenRouter, or local models. Connect your own keys or use a managed provider on cloud plans.
  • Browser automation – describe a task in plain language and the agent executes it in a real browser. Like replies, extract data, fill forms, and save results to your machine.
  • OpenWork Connect (MCP gateway) – add an MCP server or skill once, and every teammate gets it instantly across desktop, web, and any MCP-compatible client like Claude Code or Cursor. One URL covers your whole org, with auth, roles, and policies applied in transit.
  • Skill and plugin sharing – Anthropic-compatible plugins and SKILL.md files work as-is. Teams package skills, configs, and MCP servers into a single shareable link.
  • Local-first privacy – in desktop mode, files stay on your machine. Prompts go directly to the LLM provider you choose. Cloud workers are optional and sandboxed.
  • Self-host or managed – run it on your own infrastructure or use OpenWork Cloud for central seat management, SSO, and bring-your-own inference.

For teams migrating from Claude Cowork, existing SKILL.md files and MCP servers import without modification. The free desktop app needs no account to start. Team plans add API access and the Extension Marketplace at $10 per seat per month after the first five free seats.

Manages a team of AI agents across your company, with every agent, skill, memory, and connector stored as versioned files in a git repo you own and self-host.

Screenshot of the Kortix website

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.

Autonomous AI agent framework that operates on its own sandboxed computer, creates tools dynamically, manages memory, and executes multi-step workflows with full transparency.

Screenshot of the Agent Zero website

Agent Zero is an agentic AI framework built for people who want autonomous AI that actually does work, not just answers questions. It runs inside a sandboxed Docker environment with its own terminal, file system, and browser, so agents can execute real tasks end-to-end without touching your local machine unless you explicitly connect them.

The core idea is that agents shouldn't need pre-built tools for every situation. Agent Zero creates tools on the fly as tasks demand them, learns from past runs, and self-corrects when something goes wrong. Workflows are fully transparent: you can see what the agent is doing, why, and what it's executing at every step.

Key capabilities:

  • Multi-provider support: Connect any LLM provider without exposing API keys to the agent itself.
  • Dynamic tool creation: Agents write and reuse tools as needed rather than relying on a fixed library.
  • Agentic memory and RAG: Persistent knowledge management lets agents recall context across sessions and build on prior work.
  • Subordinate agents: Spawn specialized sub-agents to handle parallel or delegated tasks within a single workflow.
  • Plugin Hub: Browse, install, and update community plugins directly from the UI, with built-in AI-driven security scanning before deployment.
  • A0 CLI Connector: Bridge the sandboxed agent to your local terminal and project files when you need it.
  • Context engineering: Prompt structure is tuned to stay efficient on local models and scale to larger ones without bloat.

Agent Zero suits developers and power users who want a self-hostable AI personal assistant they can extend, audit, and fully control. Unlike closed systems such as ChatGPT or Manus, every layer is inspectable and modifiable.

The project also has a community governance layer backed by the A0T token on Ethereum BASE L2, letting token holders vote on feature priorities and development allocation. Venice AI integration gives community members access to private AI API keys at no cost.

Self-hostable desktop app that runs a coordinated team of AI agents to browse the web, manage files, execute terminal commands, and complete complex workflows.

Screenshot of the Eigent website

Eigent is a desktop application that puts a multi-agent AI workforce on your machine. You describe a task, and a pool of specialized agents divides it up, works in parallel, and delivers results. It's built for people who want AI to actually finish work, not just assist with it.

The core idea is "cowork": agents operate alongside you in your desktop environment with access to your local files, browser, and terminal. You can run a single focused agent for direct tasks or spin up a full workforce where agents collaborate across steps. A Browser Agent handles web research, a Document Agent reads and writes files, a Terminal Agent runs shell commands, and a Multi-modal Agent processes images and other media.

Key capabilities include:

  • Scheduled automation: set recurring workflows so agents run tasks on a timer, even when you're not at your desk
  • Local-first execution: files, credentials, and context stay on your machine; nothing has to leave it
  • Model agnostic: connect cloud APIs, enterprise model gateways, or local inference. No vendor lock-in
  • MCP and skill support: track which tools, skills, and referenced files each agent uses during a task
  • Agent folder: every file an agent creates or modifies during a task is surfaced in one place for review

The open source version is fully self-hostable with your own API keys or local models. It's built on CAMEL-AI, a multi-agent framework, and runs on Mac, Windows, and Linux.

For teams doing research-heavy work, competitive analysis, report generation, or any task that involves pulling from multiple sources and producing structured output, Eigent is closer to OpenHands than a simple chat interface. It's designed to complete multi-step work end-to-end rather than hand control back to you at every turn.

Leon is an AI-powered virtual assistant that lives on your server, automating tasks and managing your digital life with privacy and customization.

Screenshot of the Leon website

Leon is your open-source personal assistant designed to live on your server and automate your digital life. Built on Node.js, Python, and AI concepts, Leon offers a privacy-focused alternative to commercial virtual assistants.

Key features of Leon include:

  • Privacy-first: Leon runs on your own server, giving you full control over your data and interactions.
  • Modular architecture: Easily extend Leon's capabilities with custom packages and modules to fit your specific needs.
  • AI-powered: Leveraging natural language processing (NLP), text-to-speech (TTS), and speech-to-text (STT) technologies for intuitive interactions.
  • Multi-platform support: Interact with Leon through various interfaces, including web, mobile, and command-line.
  • Customizable voice: Choose from multiple TTS and STT options, including offline solutions for enhanced privacy.
  • Open-source community: Benefit from continuous improvements and contributions from a passionate developer community.

Leon empowers you to automate your virtual life by handling tasks, managing information, and providing assistance across various domains. Whether you need help with scheduling, information retrieval, or custom automation workflows, Leon can be tailored to your specific requirements.

Getting started with Leon is easy:

  1. Install Leon on your server using the provided CLI tool.
  2. Customize Leon's modules and skills to suit your needs.
  3. Interact with Leon through your preferred interface.
  4. Enjoy a personalized, privacy-respecting virtual assistant experience.

Join the Leon community today and take control of your digital life with an open-source assistant that puts you in charge.

Run persistent AI bots that sign into your tools, complete tasks autonomously, and ask for approval when needed. Your keys, your model, your infrastructure.

Screenshot of the Rakazo website

Rakazo is a self-hosted platform for running AI agents that actually do things. Each bot gets a sandboxed browser and shell, signs into your tools the way you would, and completes tasks while you're away. It's a direct Grok Bot alternative built around one principle: you own everything.

Bots run in Docker on your own machine, behind your firewall. Sessions and credentials never leave your infrastructure. You point each bot at whatever model you want (Claude, GPT, Grok, or a local model), and you can mix and match per bot. The cheap model triages; the smart one writes.

Setup starts with an interview. A new bot asks you a few questions about the work, your writing style, and which tools it should use. Then it gets going.

What bots can handle out of the box:

  • Inbox Manager archives noise, replies to routine threads, and parks drafts for your review
  • Sales Outbound researches accounts overnight, scores intent, and drafts outreach in your voice
  • Talent Scout reads applicants, shortlists against your criteria, and writes intro emails
  • Bug Triage reproduces reports in a real browser and attaches reproduction steps to the issue
  • Expense Manager matches receipts to charges and files reports, asking before guessing
  • Chief of Staff runs briefings, bookings, and handoffs between your other bots

Routines are saved as plain Markdown. Show a bot a workflow once and it writes a routine you can read, edit, and commit to version control. Approvals are configurable: set what a bot may do alone and what it must ask you about first. Every action lands in an audit log you own.

Rakazo is Apache-2.0 licensed with no seats, no pricing tiers, and nothing gated. Unlimited bots, no limits on usage. A managed cloud option (where you bring your own keys and they run the sandboxes) is planned, with no migration required when it arrives.

Desktop app that lets multiple AI agents collaborate as a team, using your existing ChatGPT, Claude, Gemini, or Grok plans, with workspaces and conversations stored locally.

Screenshot of the OpenBot website

OpenBot turns AI models into a team of persistent agents that work together on your computer. Instead of one chatbot answering questions, you get named agents with individual instructions, workspaces, and conversation histories. They message each other, hand off tasks, and review each other's work, so a bug found by one agent can be fixed by another and merged by a third, without you orchestrating every step.

The app is free for personal use and runs on macOS, Windows, and Linux. Workspaces, conversations, attachments, and browser data live on your machine, though agents still connect to the model providers you choose.

What agents can do:

  • Use plans you already pay for. Connect Codex, Claude Code, Gemini, Grok, OpenCode, Cline, Cursor, or any OpenAI-compatible endpoint, including local models via Ollama or LM Studio.
  • Built-in browser. Agents open, read, and control web pages inside a browser that's part of the app, so they can interact with live sites without extra setup.
  • Task queue. Send more work while an agent is busy. Messages wait in a queue you can pause, resume, or cancel.
  • Automatic failover. When a plan hits its usage limit or a provider goes down, an agent switches to a backup model and keeps its chat and workspace intact.
  • Agent persistence. An agent keeps its full context when you restart the app or switch it to a different provider.

Each agent has its own name and instruction set. You describe what you want in a prompt, review the generated instructions, and the agent is ready. Teams grow naturally: add more agents and they coordinate around whatever work is in flight.

For teams that need always-on availability, a managed server option runs OpenBot outside any single laptop, with shared or per-employee environments and custom integrations into existing tools and APIs. The source code is available under the PolyForm Noncommercial license, so you can audit what the app does, but commercial use requires a paid license.

Personal agent that chases invoices, preps client calls and cancels trials on real websites. Runs on your own computer with the AI provider you pick.

Screenshot of the Nod website

Nod is a personal agent with its own computer. It does errands on real websites and in your connected apps, and it asks before it acts for you. It's built for people who run their own work: client calls, follow-ups, invoices, supplier portals. Life admin like refunds and bookings works too.

It comes from the team behind n8n, but it's a separate app and doesn't require n8n.

  • Call briefs: each morning it reads your threads, calendar and the client's latest news, then writes a one-page brief.
  • Unanswered questions: it finds what you never replied to and drafts an answer from your own pricing sheet.
  • Monitoring: ask it to watch a pricing page. It checks on a schedule and speaks up only when something changes.
  • Errands: chasing invoices, filing month-end statements, turning client requests into Linear tasks, comparing and booking offsite venues.
  • Memory: every note is visible, editable and can be forgotten. It learns your writing style from sent emails and reuses steps it has learned, fixing them when a site changes.

Permissions are the core idea. Nod checks each action against your request and your rules, and asks when they don't cover it. Its safety check is a model's judgement, so it can make mistakes. A Usage view shows recorded app actions, sign-ins and estimated model costs.

It runs on macOS, with Windows 11 and Linux x64 in preview, or on your own server. Bring OpenAI, Anthropic, Google or OpenRouter keys, a ChatGPT Plus or Pro plan, or a local model through Ollama, LM Studio, vLLM or llama.cpp. Nod is free under Apache 2.0; you pay only your model provider.

Run Claude Code, Codex, Cursor, and 40+ AI agents as persistent bots across iPhone, Mac, Windows, and Linux with group chats, approvals, and end-to-end encryption.

Screenshot of the Codync website

Codync gives you persistent, named AI bots that live on your own computer and stay reachable from your iPhone, Mac, Windows PC, or Linux machine. It's a free, Grok Bot alternative built in the open, so you're not locked into one model or one subscription. No paid tier, no hidden fees.

Each bot keeps a continuous chat. You see its final reply by default; tool calls and intermediate steps are there when you want them. Bots remember context across sessions and can be given standing instructions and a project scope.

What you can do with bots:

  • Group chats put multiple bots in one room. They read each other, disagree, and hand work back. Mention one with @ to direct a question at it specifically.
  • Approval cards surface file edits and shell commands as allow-once, always-allow, or deny prompts on your phone. Nothing runs without your say.
  • Per-bot memory carries context across sessions, so a bot doesn't start cold every time.
  • Routines run on a schedule or a webhook trigger.
  • Remote screen and voice let you watch, control, and talk to a bot from your phone.

Codync speaks the Agent Client Protocol, so it works with Codex, OpenCode, Grok Build, Claude Code, Cursor, Gemini, Copilot, and around 40 more. Each bot picks its own agent. Mix them in one room. You use the logins and plans you already have; Codync never calls a provider's API on your behalf.

The host is a single Rust binary. It runs on macOS, Windows, and Linux, including headless servers. The iPhone app is native SwiftUI. There's also a full terminal UI for SSH sessions. All clients talk to the same host, so your bots and chat history are consistent everywhere.

Privacy is structural. Bots, transcripts, and memory stay on your computer. Your phone connects directly on the same network, or through an end-to-end encrypted relay anywhere else. The relay forwards ciphertext only. Even push notification text is sealed to your phone's key, so the relay never sees what your bots said.

Apache 2.0 licensed. The only costs are the agent plans you already pay for.

Share: