Your own always-on AI bot, on any model: hands-on with AnyModelBot

AnyModelBot (modelflare-ai/AnyModelBot, MIT, 1,198 GitHub stars) is a local-first, open-source alternative to Grok Bot, OpenAI dots and Claude Duet: it runs on your own Windows, macOS or Linux machine, reaches GPT, Claude, Gemini, Grok, DeepSeek, Kimi, GLM and 70+ more models through one Modelflare account billed per token, and works in the background with approval cards for anything outside its workspace. This guide installs v0.1.16, signs in to Modelflare, builds a bot with its own workspace and permissions, gives it a background task and a scheduled rule, and reaches it from a chat app, plus the Docker route for a server.

• Who: AnyModelBot, by modelflare-ai on GitHub. Its models come from Modelflare, an AI API gateway run by Havenbyte LLC, a US company with 200,000+ registered developers.
• What: A local-first, always-on personal AI agent app (MIT licence) for Windows, macOS and Linux, plus Docker and a local web console. Each bot has its own persona, default model, workspace and memory.
• When: Repository created 27 October 2026; v0.1.16 released 2 November 2026. At research time on 2 November 2026: 1,198 GitHub stars.
• Models and cost: 70+ text, image and video models from 13 providers through one Modelflare account, billed per token, with a public price list. The app itself has no subscription.
• Permissions: Three tiers per bot: read-only, workspace (the default: writes only inside its own folder, asks first outside it), and full access (no sandbox; recursive delete still asks first).
• Budgets and quiet hours: Each background task defaults to a $1 budget; each scheduled rule defaults to $0.10 per run and $3 per month. Do-not-disturb runs 22:00 to 08:00 by default, and proactive messages are capped at 3 per day on WeChat and 5 per day on other channels.

Why this matters now

In the second half of 2026, the always-on personal agent became the product every lab wanted to ship: xAI's Grok Bot, OpenAI's dots and Anthropic's Claude Duet all promise an agent that watches things for you, works in the background, and comes back when a decision is yours. The catch is the same in each case: the agent lives on someone else's computer, runs one vendor's models, and arrives attached to a subscription. AnyModelBot is the same idea with the dependencies inverted. It is open source under the MIT licence, it runs on your own machine or server, and it can use GPT, Claude, Gemini, Grok, DeepSeek, Kimi, GLM and more than 70 other models through a single gateway account that bills per token. The project says its design draws on DeepSeek's super-agent prototype and that the agent itself runs on DeepSeek Harness.

That inversion is the whole pitch, and it comes with the matching trade-off: you are the operator. Your computer has to be on for background work to run, you approve the actions that leave a bot's workspace, and you watch the per-token spend. What follows is the honest version of the setup: install it, connect the one account it needs, build a bot with tight permissions, and give it exactly one background job before you trust it with more.

What you’ll need

A computer running Windows, macOS or Linux; a Modelflare account (sign-up is free, model use is billed per token, so add funds before you ask it to do real work); and, only for the server route in Step 6, Docker, or Node.js 22 for the from-source route. No subscription to any model provider is needed, and no API key needs to be copied by hand on the desktop install: first launch opens a browser sign-in and the app connects the device itself.

Step 1: Install v0.1.16 and verify the download

Download the installer for your platform from the project's Releases page. Each release lists every package plus a SHA256SUMS file: anymodel-bot-0.1.16-win-x64.exe or -win-arm64.exe for Windows, anymodel-bot-0.1.16-mac-arm64.dmg or -mac-x64.dmg for macOS, and anymodel-bot-0.1.16-linux-x86_64.AppImage or -linux-arm64.AppImage for Linux. Verify the file before you run it:

sha256sum -c SHA256SUMS --ignore-missing

On macOS, compare with shasum -a 256 <filename>; on Windows PowerShell, use Get-FileHash <filename> and check the value against SHA256SUMS. On first launch, expect the usual unsigned-app friction: Windows asks you to choose “More info” then “Run anyway”, macOS asks you to choose “Open Anyway” in System Settings under Privacy & Security, and Linux needs the AppImage made executable with chmod +x first. Closing the window sends the app to the system tray rather than quitting it; use the tray menu, or the option in Settings, to exit. If you prefer the interface in English, switch languages in Settings: the project ships in Chinese and English.

Step 2: Sign in to Modelflare once, then pick a model per conversation

First launch opens your browser for Modelflare sign-in. After that, the app lists your models itself; on Docker or a server you paste an API key instead. Every model in the picker shows its context length, capability tags and reference price, and you can switch models per conversation with the picker or with the /model slash command. Give each bot a default model, and use a cheaper model for the small background jobs — memory tidying and context handover can have their own model set separately. Two routes are offered, international and China-optimised, and you choose one yourself; the app does not switch between them automatically. Check the public price list before you settle on a default: Modelflare advertises discount groups (a 0.015x multiplier for GPT and 0.03x for Claude after a qualifying single top-up) and cache-hit guarantees of 65%, 75% and 85% on its three OpenAI groups, but those are limited-time offers whose thresholds live on Modelflare's site, not promises in this guide. Your balance, low-balance reminders and daily usage are visible inside the app.

Step 3: Build a bot with a persona, a workspace and tight permissions

A bot is a persona with its own default model, workspace and memory. Create one and write its persona as a sentence or two about what it is for — the templates are only starting points, and every word is editable. The six avatars change only how it looks, not what it can do. Then set its workspace to one folder you actually want it to work in, and leave permissions on the default workspace tier: it may write inside its own folder, and anything outside it stops for an approval card first. The other tiers are read-only and full access, which skips the sandbox entirely, although recursive deletion still asks first. Do not start on full access. Test the boundary on purpose: ask the bot to tidy a messy folder, watch it list the files and propose a plan, and confirm that moving a file outside its workspace waits for your approval. While you are there, teach it one preference and check the info panel: memory is stored as Markdown in three layers (team, bot and group), content that looks like a secret is filtered out, and a new conversation should already reflect what it remembered. Use /reset to start a conversation over when an experiment goes sideways.

Step 4: Give it one background task and one scheduled rule

Background work is where this kind of agent earns its keep, so give it a small, verifiable job first. Ask it to research something or write a short report in the background — or say “in the background” — and keep chatting about something else while it works; the result comes back to the original conversation, and every step is visible in the task detail view. Then add a rule in plain language, for example: every morning at 8:00, check a price, and only tell you if it drops below a threshold you set. Before you let a rule act, run it in observe mode: it records what it would have said without sending messages or changing files, so you can read a few runs and only then switch it to execute. Everything that needs you — an answer, an approval, a retry — collects in the sidebar under “Needs you”; when nothing is waiting, that row does not appear. Two guardrails are on by default and worth leaving alone at first: a task budget of $1 and a rule budget of $0.10 per run and $3 per month (both editable), and quiet hours from 22:00 to 08:00 with proactive messages capped per day. If background work ever feels noisy, one switch under Bot Settings and proactive messages pauses it while chat keeps working. Tasks and run records are kept for 30 days, task folders idle for 30 days are deleted automatically unless you mark them to keep, and run records can be exported as Markdown.

Step 5: Reach the bot from a chat app, and keep it owner-only

Add a channel once in Settings and every bot shares it: WeChat by scanning a code, Feishu with streaming reply cards, and Telegram, Slack or Discord with a token under Settings and Connections, with no public address needed. Channels currently handle one-to-one chats only, and in a chat app you switch bots with /bot name. By default a bot only answers its owner — the account that scanned the WeChat code, or the first person to message it on the other channels — and anyone else gets a short prompt instead of a model call; approve additional people from the info panel. The same accounts can give a bot read access to your Notion and Feishu messages, which is powerful and exactly the place to be careful: anything the bot reads there can end up in a model request, so connect those accounts only for a bot whose workspace you trust. Inside the app itself you can also put several bots in a group chat and @ the one you want; each bot answers with its own model, workspace and memory, and costs are tracked separately.

Step 6: Run it on a server with Docker, or from source

If you want the bot reachable when your laptop is shut, run it on a machine that stays on. The documented Docker route is:

docker run -d --name amb -p 3600:3600 -v amb-data:/data ghcr.io/modelflare-ai/anymodel-bot
docker exec amb cat /data/ui-token   # then open http://<host>:3600/?token=<token>

Do not expose port 3600 directly to the internet; the README says so explicitly, and the token in /data/ui-token is the only thing standing between that port and your conversations. On a server you paste a Modelflare API key instead of using browser sign-in. The from-source route, for people who want to read or change the code, is:

git clone https://github.com/modelflare-ai/AnyModelBot.git
cd AnyModelBot
npm install
npm run setup      # fetches and builds the bundled gateway
npm start          # local console: http://127.0.0.1:3600/

From source you need Node.js 22. The local console binds only to 127.0.0.1, and the desktop app generates a fresh access token on every start. Computer control, via the bundled Cua driver, is the one feature to enable deliberately rather than by default: it can operate your desktop, reads of screen content never need approval, and you can switch a bot to ask before every click and input. MacOS computer control is still in beta, and computer control needs a real desktop session, so it is not a server feature.

What you built, and where it stops

You now have an always-on bot that lives on your hardware, answers on any of 70+ models through one pay-per-use account, keeps its memory and files on your device, works in the background under a budget, and asks before it steps outside its workspace. What it is not: a way to avoid paying for models (every request is billed per token, and background rules only stay cheap while their budgets hold); a substitute for a vendor subscription's hosted reliability (if the machine is off, scheduled rules do not run); or a sandbox (full-access bots run unsandboxed, and even the default tier's protection is an approval card, not isolation). The project is days old at v0.1.16, so expect the interface and the roadmap to move: custom MCP servers, email and calendar triggers, group chats inside chat channels, bot-to-bot handover and a standalone mobile app are all listed as not yet built, and the deepest write-up of the super-agent design is currently Chinese-only. And the privacy boundary is stated honestly in the project's own docs: conversations, memory, files and keys stay on your device, but anything you send to a model leaves it through Modelflare, which keeps request logs — check its trust centre for what is kept and for how long before you point the bot at anything sensitive.