Guide

Why ModelBuff

A local scheduling and clean-isolation workstation for power users running multiple AI subscriptions and agents.

  • Swap models, keep your agent
  • Dual-window scheduling
  • Sandbox & browser
  • Official CLI, no proxies

Six gaps in today's AI workflow

As subscriptions and agents multiply, these six friction points break your flow and account safety.

  • Models leapfrog, yet your agent stays put

    New models take the lead monthly, yet your rules and muscle memory live in one favorite agent.

  • Proxies & mixed hosts risk account bans

    Third-party credential relays and cloaking break and violate terms; dirty hosts add exit-mismatch risks.

  • Quota is siloed: stalled or expired

    One account stalls on a rate limit while backups expire — and naive round-robin wakes every 5h clock early.

  • Accounts & browsers collide; VMs are heavy

    Official CLIs and browsers share one cookie jar by default; running a VM or cloud box per account is slow and costly.

  • Media credits stay trapped in browsers

    Paid web credits on RunningHub, LibTV, Dola, and Muse require manual clicking instead of agent calls.

  • Spend, cache & routing are a black box

    Disconnected vendor dashboards hide cache savings, subscription offset, and what fills your context window.

How ModelBuff solves it

Decouple models and subscriptions from your favorite agent — drive official CLIs in local sandboxes over standard protocols.

  • One workbench — swap models, keep your agent

    Switch to today's strongest model while staying in Claude Code, Codex, Cursor, or your terminal. Unite subscriptions, coding plans, and APIs via desktop setup, directory shims, or the local gateway.

  • Dual-window scheduling

    Drains expiring 7d quota first, protects idle 5h windows, balances active load, and hands off live on 429 limits.

  • Light sandboxes & account browsers

    Each sandbox starts clean with its own directory, chained fixed exit, exit checks, and a native Chrome/Edge account browser — fail-closed.

  • Directory & group routing

    Directory locks separate work and personal accounts; group boundaries contain failovers; smart groups route across vendors.

  • Run the official CLI natively — no proxies or cloaking

    Nothing bundled or version-locked — ModelBuff runs your machine's official CLI inside a clean sandbox.

    Reverse-proxying a subscription

    • Credential extraction — lifts login tokens into a third-party relay
    • Fragile breakage — breaks whenever upstream headers or auth update
    • Ban risk — violates vendor terms and invites sudden suspension

    ModelBuff's native architecture

    • Sealed locally — credentials never leave each account's sandbox
    • Official CLI native — signs in and talks directly over ACP / MCP
    • Zero cloaking — system prompts stay untouched; tracks official updates
  • Live quota, dual ledger & traces

    Tracks 5h/7d windows live and unifies gateway + native CLI sessions: cache savings, routing hops, and turn-by-turn context.

  • Web media over MCP

    Turns RunningHub, LibTV, Dola, and Muse web credits into standard MCP tools that save straight into your project.

  • Local redaction gateway

    Listens only on 127.0.0.1:28330 across major formats; masks keys and swaps paths reversibly without hurting cache hits.

Want the five engineering principles behind this? Read Philosophy

One closed loop per account

No VMs or heavy containers — every account runs locally in five steps, stopping if a sandbox or exit boundary breaks.

  1. Fixed exit

    • Your own nodes — bind your own proxies or import subscriptions via modelbuff egress import
    • Built-in protocols & per-hop load balancing — native HTTP, SOCKS5, VLESS, Hysteria2, Trojan & Shadowsocks with multi-hop chains; entry & intermediate hops balance via fastest / round-robin / failover while the exit hop stays pinned per account by default (with opt-in same-hop failover)
    • Shared route — the CLI and account browser share one fixed exit
    • Fail-closed — returns 502 and halts when unreachable, never falling back direct
  2. Clean sandbox

    • Born clean — host configs and system keychains cannot enter the sandbox
    • Per-account context — carries its own 0700 directory, fixed exit, and matched timezone & locale
    • Synced presets — desktop auto-matches 7 region presets (editable anytime) and syncs to the account browser
  3. Environment risk check

    • Diagnostic only — inspect anytime with graded remediation hints; never halts runs
    • Exit & leak checks — verifies exit IP, latency, IP reputation, remote DNS & WebRTC
    • Region & sandbox — checks timezone/locale match and confirms host credentials stay outside
  4. Account browser sign-in

    • Native profile — reuses local Chrome, Chromium, or Edge with an isolated 0700 profile & color badge
    • Leak-blocked — shares the CLI's fixed exit while blocking local DNS and non-proxied WebRTC
    • OAuth & one-click — modelbuff login opens auth pages here; account cards launch it in one click
    • User-completed — you complete sign-in, phone & 2FA yourself with zero auto-fill or interception
  5. Official CLI launch

    • Folder-bound — PATH shims match the current directory and run the official CLI inside its sandbox
    • Native binary — runs your installed official CLI without bundling or pinning versions
    • Gateway relay — multi-account failover runs through the local gateway

Account environment risk check

CLI
modelbuff egress check verifies reachability, per-hop available & selected candidates, actual exit IP, remote DNS & latency; modelbuff sandbox diagnose runs full per-account checks (--json & offline mode)
Desktop
Per-account diagnosis & per-hop egress check showing available and selected candidates at every hop; Test All in Network checks latency & exit IP
Web
Official check page, also opened as the account browser's default homepage
Privacy
IP reputation checks send your exit IP to third-party reputation services and can be turned off; sandbox diagnose also supports offline mode

Where ModelBuff stands beside similar tools

Several strong open-source projects serve different layers of the stack. Here is where each shines and where ModelBuff differs.

Where ModelBuff focuses

  • Dual-window scheduling
  • Directory & group routing
  • Sandbox & browser
  • Official CLI, native
  • Dual-source analytics
  • Media over MCP
  • Redaction gateway
  • CC Switch

    Desktop config hub for coding tools: one-click API provider switching plus MCP, skills, and prompt management.

    Pick it if

    You mainly switch pay-as-you-go APIs or want one place to manage MCP servers, skills, and prompts.

    How ModelBuff differs

    CC Switch focuses on config switching; ModelBuff focuses on concurrent isolated accounts and smart scheduling.

    • Concurrent clean accounts

      Subscriptions stay online in parallel with zero config overwrites.

    • Directory auto-binding

      Entering a project folder locks in the bound account automatically.

    • Dual-window handoff

      Drains expiring weekly quota first and relays live on rate limits.

    Seamless migration: reads CC Switch configs read-only and supports ccswitch:// links natively.

  • Magpie

    Local multi-protocol model gateway with broad OpenAI, Anthropic, and Gemini translation and flexible run modes.

    Pick it if

    You want a general-purpose local gateway with wide protocol translation.

    How ModelBuff differs

    ModelBuff goes deep on per-account clean sandboxes and native official-CLI isolation.

    • Native sandboxed CLI

      Runs official CLIs inside featherweight sandboxes, tracking upstream updates.

    • Account browser & exits

      Directories, cookies, timezone, locale, and multi-hop exits stay bound — fail-closed.

    • Directory-aware CLI flow

      Resolves isolated identities by directory across desktop and terminal workflows.

    Seamless migration: imports Magpie / OpenCode configs read-only and supports compatible ESM plugins.

  • claude-code-router

    Local routing control plane for coding agents: routes and pools API keys by priority, weight, and quota.

    Pick it if

    Your capacity is mostly API keys and you want fine-grained request routing.

    How ModelBuff differs

    ModelBuff solves the subscription side: isolation, concurrency, and rolling-window pacing.

    • Clean per-account sandbox

      Multiple subscriptions stay physically separated with zero contamination.

    • Same-vendor concurrency

      Keep multiple same-vendor subscriptions online together under one scheduler.

    • 5h × 7d scheduling

      Optimizes short and weekly windows automatically with live failover.

  • CLIProxyAPI

    Server-side OAuth proxy exposing OpenAI-, Gemini-, and Claude-compatible APIs via binary or Docker.

    Pick it if

    You need a server-hosted compatible-API proxy.

    How ModelBuff differs

    Different model: CLIProxyAPI holds credentials and relays requests (prompt cloaking enabled by default, optional); ModelBuff stays local and native.

    • Credentials stay local

      Never extracts subscription credentials into a relay server.

    • Official CLI talks directly

      Each account signs in and sends traffic from inside its own sandbox.

    • Untouched prompts

      Zero cloaking — system prompts are never rewritten.

  • sub2api

    Multi-user server distribution platform turning subscriptions into platform keys with auth and billing.

    Pick it if

    You want a multi-user platform with accounts, billing, and top-ups.

    How ModelBuff differs

    Different category: ModelBuff is strictly a single-user local workstation.

    • 100% local software

      Installs on your machine with no server, cloud account, or billing.

    • Personal use only

      Never built for multi-tenant sharing or subscription resale.

  • new-api

    Self-hosted AI gateway for teams: centralizes upstream channels, unified keys, groups, and billing.

    Pick it if

    You need team permissions, multi-user groups, and centralized governance.

    How ModelBuff differs

    Built for different layers — and naturally complementary.

    • Personal mastery

      new-api governs team APIs; ModelBuff maximizes one developer's subscriptions and agents.

    • Works alongside

      Connect your team's new-api endpoint to ModelBuff like any standard provider.

When you don't need ModelBuff

  • One plan & one agent

    Using one subscription and one client? The official tool alone is plenty.

  • Basic API switching

    No isolation, dual-window pacing, or trace needs? A simple switcher is lighter.

  • Team distribution

    Pick a team gateway for multi-user billing; ModelBuff stays a personal local tool.

Running multiple AI subscriptions and agents and want clean isolation with zero wasted quota?

3-minute quickstart