Open source Grok Bot alternative, Bring your own agent and subscription: message Claude Code, Codex, Gemini CLI, Cursor, Copilot and 40+ AI agents as bots on your own computer, from iPhone, Mac, Windows, Linux or terminal. Agent-agnostic and free. Also a Muse and Dots alternative. Built in Rust.
Rust acpagent-client-protocolai-agentsai-assistantclaudeclaude-codecodexcoding-agentscursorgeminigemini-cligrok-bot-alternativeiosiphonelinuxmacosmcpopen-sourcerustself-hosted
Conversation runtime
- Chat ≠ session: a bot is one endless transcript (SQLite
entries, ordered byseq); the ACP session underneath is reopened withsession/load, orsession/resumeon an agent without it (DeepSeek Harness), or replaced by New session. The chat never says when the session underneath changes (New session, an agent, model or folder change, a failed resume); only a rollover's handoff card mentions a fresh conversation (context and memory), and one line says when another agent takes over or the bot's own comes back. - Agent fallbacks: when the bot's agent can't answer (out of usage, rate limited, signed out, won't start), the next agent in its list carries the same turn on, told what the last one did; each agent keeps its own session, parked while another answers, and agents rest computer-wide until they recover: docs/features/agent-fallback.md.
- Agent processes: a bot's agent starts on its first message and keeps its sessions loaded between messages. A session unused for 30 minutes is closed (agents with
session/close; a routine run's session as soon as the run ends), and once all of them are idle the agent stops with its process group, as it does right after a routine run when no other session is open; the next message starts it again and reopens the session (agent/bot/lifecycle.rs). Nothing is released mid-turn or while a queue, approval or request waits. Agents that can't reopen sessions stay, and so do agents with something running detached in a session of its own, like a dev server from Claude Code's shell tool (stopping the agent would orphan it); MCP servers don't count, even in a process group of their own as Codex starts them. Codex keeps a closed session's MCP servers until the agent stops, and codex-acp never closes the thread it titles each new session in (codex-acp#628), so on Codex only the agent stopping gives them back. Windows has no sessions to tell a dev server from an MCP server, so there the agent's job is checked instead: anything that isn't the agent or Codync's MCP servers holds it, which also keeps an agent with an MCP server from the user's own config or a shell it keeps open, and one with no MCP server left, whose own last process can't be told from a dev server (agent/bot/background_work.rs). A dev server the bot starts withstart_dev_serverbelongs to the host and doesn't hold the agent (dev servers). - Group chats and replies are host features every client drives through the same methods (
sendwithreplyTo,createBot {kind: group}); clients never route, parse mentions or build quotes themselves. A group is a roster row whose members answer in their own sessions (Grok Bot's room turns); a reply stays in its chat and session, its quote read before its text: docs/features/groups-and-replies.md. - A session that fails with an internal error its agent gives no category (JSON-RPC
-32603withoutdata.errorKind) is closed right after the turn, when the agent can close and reopen sessions: Claude's adapter otherwise answers every later prompt on it with "The Claude Agent session has ended". The next message reopens it and the conversation carries on (acp::may_end_session). - Lead bot: the host makes the first one per computer (
chat/lead.rs), and the user may pick another (setLead) or delete it; on top of every roster, never hidden; its instructions ask for initiative, the Check in routine made with the first runs twice a day, and it opens a call with a turn of its own (Cmd::Prompt, no user message): docs/features/lead-bot.md. - Bot collaboration: built-in
teamMCP (chat/team.rs) lists visible bots and sends one a request through its actor queue (message_bot); nothing waits, and the reply comes back to the sender as a turn of its own in its main chat. Requests and replies are separate turns, bounded by the chain's hop count; native subagents stay with the harness. See docs/features/bot-collaboration.md. - Context & memory: frozen instruction snapshot per session + compaction epoch (Claude gets it as a system prompt), profile edits as update blocks, memory in the host (a layer shared by all bots and one per bot, written by the user, the bots' tools and dreaming), busy-time messages folded into one turn or steered into the running one, interrupted turns resumed: docs/features/context-and-memory.md.
- Chat shows only: user messages, the bot's messages (
data.final: eachsend_messagecall from the built-inchatMCP, Grok Bot's way, also between turns from work the agent goes on with in the background, into the bot's own chat with a done alert, unless the user stopped its last turn; a turn that sent none falls back to its last text, unless it reacted to the user's message instead or passed), permission cards, notices. Nothing streams into a bubble; narration, thoughts, tool calls, plans are trace entries (Full conversation sheet; with Show thinking details on (Settings › Chat), the live activity also unfolds the running turn's steps, without the bot'sbookkeepingtool calls): docs/features/chat-messages.md.