English | Deutsch | Nederlands | Francais | Russkij | Espanol | Portugues

Multi-provider AI agent control from your phone.

Quick Start · How It Works · Features · Use Cases · Install Guide · Architecture

Run Claude Code, OpenAI Codex CLI, or Google Gemini CLI from Telegram or Matrix. Uses only official CLIs as subprocesses — nothing spoofed, nothing proxied. Your subscriptions, your machine, your data.

Released March 12, 2026 — five days before Anthropic shipped Claude Dispatch. Same concept, different philosophy.

Step 1: Install Python (skip if you already have Python 3.11+)

# macOS
brew install python@3.11

# Ubuntu/Debian
sudo apt update && sudo apt install python3 python3-pip python3-venv

# Windows — download from https://www.python.org/downloads/
# ✅ Check "Add Python to PATH" during install

Step 2: Install pipx (a tool for installing Python apps)

# macOS
brew install pipx && pipx ensurepath

# Linux
pip install pipx && pipx ensurepath

# Windows
pip install pipx
pipx ensurepath

After running pipx ensurepath, close and reopen your terminal for the command to work.

Step 3: Install MOPS

pipx install memoriant-ops-bot

Step 4: Install at least one AI CLI (the agent MOPS will control)

# Pick one or more:
npm install -g @anthropic-ai/claude-code && claude auth     # Claude
npm install -g @openai/codex && codex auth                   # Codex
npm install -g @google/gemini-cli                            # Gemini (auth in CLI)

Don't have Node.js? Install it first: brew install node (macOS) or sudo apt install nodejs npm (Linux) or download from nodejs.org

Step 5: Get a Telegram bot token — see the Telegram Setup Guide

Step 6: Run MOPS

mops

The onboarding wizard walks you through transport setup (Telegram or Matrix), timezone, optional Docker sandbox, and background service installation.

MOPS wraps official CLI binaries as subprocesses and bridges them to your messaging platform. No API keys, no SDK patches, no spoofed headers. When you send a message on Telegram, MOPS passes it to the CLI exactly as if you typed it in your terminal.

Phone (Telegram/Matrix)
  |
  v
MOPS daemon (your machine)
  |
  +---> claude     (subprocess)
  +---> codex      (subprocess)
  +---> gemini     (subprocess)
  |
  v
Response streamed back to phone

All state lives in ~/.mops/ as plain JSON and Markdown. No database, no external services.

MOPS gives you five levels of interaction. Start simple, scale up as needed.

Your main 1:1 conversation. Every message goes to the active CLI, responses stream back live.

You:   "Explain the auth flow in this codebase"
Bot:   [streams Claude Code response]

You:   /model
Bot:   [switch to Codex or Gemini]

Create a Telegram group with topics enabled. Each topic gets its own isolated CLI context. Five topics = five parallel conversations, all from one group.

My Projects/
  General        -- own context
  Auth           -- own context, own model
  Frontend       -- own context
  Database       -- own context
  Refactor       -- own context

Spin up a side conversation without losing your current context. Like opening a second terminal.

You:   "Let's work on authentication"
Bot:   [responds about auth]

/session Fix the broken CSV export
Bot:   [works CSV in separate context]

You:   "Back to auth — add rate limiting"
Bot:   [picks up right where you left off]

Delegate long-running work. You keep chatting, the task runs autonomously, results flow back when done.

You:   "Research the top 5 competitors and write a summary"
Bot:   -> delegates, you keep working
Bot:   -> done, summary appears in your chat

Fully isolated second bot — own workspace, own memory, own CLI, own config. Runs on a different provider if you want.

mops agents add codex-agent

Now you have Claude in your main chat and Codex in a separate chat, working in parallel with independent contexts. They can delegate tasks to each other.

Multi-provider — Switch between Claude, Codex, and Gemini with /model. Per-topic, per-session.

Multi-transport — Telegram and Matrix run simultaneously. Plugin system for Discord, Slack, Signal.

Real-time streaming — Live message edits on Telegram, segment-based on Matrix.

Persistent memory — Plain Markdown files that survive across sessions and reboots.

Cron & webhooks — Schedule recurring tasks with timezone support. Webhook triggers for external integrations.

Docker sandbox — Optional sidecar container with configurable host mounts for safe code execution.

Background service — Install as systemd (Linux), launchd (macOS), or Task Scheduler (Windows).

Cross-tool skill sync — Shared skills across ~/.claude/, ~/.codex/, ~/.gemini/.

Hot-reload config — Change language, model, permissions, scene — no restart needed.

7 languages — English, Deutsch, Nederlands, Francais, Russkij, Espanol, Portugues.

Both run in parallel on the same agent. Adding a new messenger means implementing BotProtocol in a sub-package — the core is fully transport-agnostic.

Dual-allowlist model. Every message must pass both checks:

Allowlists are hot-reloadable. Unauthorized groups trigger auto-leave. All state is local — nothing leaves your machine.

mops                    # Start (auto-onboarding)
mops onboarding         # Re-run setup
mops stop               # Stop bot
mops restart            # Restart
mops upgrade            # Upgrade + restart
mops status             # Runtime status
mops uninstall          # Remove everything

mops service install    # Background service
mops service start|stop|logs

mops docker enable      # Docker sandbox
mops docker rebuild
mops docker mount /path

mops agents list        # Sub-agents
mops agents add NAME
mops agents remove NAME

mops install matrix     # Matrix transport
mops install api        # WebSocket API

~/.mops/
  config/config.json          # Configuration
  sessions.json               # Chat state
  named_sessions.json         # Named sessions
  tasks.json                  # Background tasks
  cron_jobs.json              # Scheduled jobs
  agents.json                 # Sub-agent registry
  SHAREDMEMORY.md             # Cross-agent knowledge
  workspace/
    memory_system/            # Persistent memory
    cron_tasks/               # Cron scripts
    skills/ tools/            # Shared tooling
    tasks/                    # Per-task folders
  agents/<name>/              # Isolated sub-agent workspaces

Other projects patch SDKs, spoof headers, or proxy API calls. That's fragile and risks violating provider ToS.

MOPS runs official CLIs as subprocesses. Nothing more. Your subscription, your machine, your auth. The bot is just a bridge between your phone and your terminal.

See CONTRIBUTING.md for setup, quality gates, and contribution guidelines.

git clone https://github.com/NathanMaine/memoriant-ops-bot.git
cd memoriant-ops-bot
python -m venv .venv && source .venv/bin/activate
pip install -e ".[dev]"
pytest && ruff format . && ruff check . && mypy memoriant_ops_bot

Security Policy · Changelog

MIT License
Built by Memoriant Inc.