Pool Your AI Subscriptions: Routing WorkBuddy and Qoder Quotas Through a Single Local Gateway
The more AI tools I install on my computer, the more cluttered it gets: Codex, ZCode, WorkBuddy, Qoder, MiniMax Code... I kept installing them just to claim freebies. When working on a project, I often need to switch between tools constantly, and I have to remember which tool I'm currently using and what step I'm on.
Now my 256 GB Mac has a dozen-plus tools installed, which is a headache. The disk alarm goes off every day.
Mac storage is already tight. With so many tools installed, what should be a productivity asset has become a burden. I know I don't really need that many tools, but who can resist the lure of free eggs?
1 The Current Predicament
1.1 Too Many Tools, Fragmented Work
Several tools open the same directory, and the source code can still be the same one. But chat histories, indexes, attachments, and workspace states often live separately. The files are connected, but what was discussed or tried earlier may not be picked up when switching tools.
If I clone a repository separately or create independent worktrees for each tool, working directories multiply. The node_modules, virtual environments, and build outputs inside might also be duplicated. But whether the package managers and compile caches can be shared depends on the actual configuration; seeing several apps installed doesn't mean the project is duplicated multiple times.
This makes me want to consolidate: keep to one primary tool daily, and switch only when other capabilities are truly needed. Multi-tool collaboration has its uses, but I don't want to decide which one to open first for every small task. But the free eggs are tempting too... I can't let go.
1.2 The Disk Is Already Warning Me
Here's my disk inventory from November 12, 2026: about 9.5 GB free, with several tool directories already taking up several GB. Below are the sizes recorded at that time, though what exactly is inside hasn't been fully dissected.
| Location | Size at the Time | What Needs Distinguishing |
|---|---|---|
~/.codex |
~22 GB | sessions, session SQLite, generated images, etc.; can't treat the whole directory as a cache |
~/.minimax |
~9.7 GB | mainly the v2 directory; sessions, attachments, caches not broken down yet |
~/.zcode |
~5.2 GB | agents, artifacts, db, and plugin caches mixed together |
| Qoder CN / ZCode's Application Support | ~2.6 / 2.4 GB | currently classified as workspace data and caches; needs further breakdown |
| Trae CN data and application | ~2.5 GB | application itself and existing project records must be viewed separately |
| 8 application binaries | ~6.8 GB total | stats overlap with the previous row |
These numbers look big, but you can't just add them up to know how much can be cleaned. Some stats overlap, and not everything in the directories is cache. Session databases, generated images, and attachments could contain things you need later, so you can't delete them just because they take up space.
Using fewer tool suites reduces new data accumulation, but the old stuff still needs separate cleanup. So I also have to consider: does adding another system actually save effort, or does it just add another thing to maintain?
1.3 Want to Reduce Entry Points but Reluctant to Give Up Existing Quotas
But sticking to a single tool gives me pause. Other accounts still have paid subscriptions, check-in points, and time-limited free quotas. Models and usage aren't necessarily in the tool I'm most comfortable with. It feels wasteful to not use them, but switching back and forth to use them brings back the original hassle.
What I'm reluctant to give up isn't necessarily the apps themselves, but the models and quotas behind them. The ideal approach: keep working in my favorite tool, and pick whichever model provider fits each task.
2 What Kind of Gateway Do I Need?
An AI gateway can sit between tools and model sources. Tools continue to read projects, operate the terminal, modify files; model requests first go to the gateway, then to the selected source, and responses return to the original tool.
Main tool or scripts supporting custom models
→ Local AI gateway
→ Selected model sources and accounts
→ Response returns to the original tool via the gateway
My requirements are simple: existing accounts or APIs can connect, common tools can call them, and I can tell which provider was used after a call. Otherwise it's just another place to fill in configuration, and the original hassle remains.
However, this "model pool" only aggregates callable models; each provider's balance stays its own. Old chats, indexes, and project copies won't merge. Another tool's interface operations and approval capabilities won't be brought along either. Fewer tool switches is one thing; old data on the disk is a separate matter.
If a tool's built-in model and quota are sufficient, just use it directly. The reason I want to go through this setup is to also use up the quotas in other accounts. Let's see which gateways can handle this.
3 Which Gateways Are Available
First look at which model sources these AI gateways connect to, then which tools they can serve, and only last do considerations like usage management. The comparison below is based on public documentation. I haven't installed each one to compare; this covers functionality and applicable scenarios, not which is faster or more stable.
| Approach | Best for | How to choose in my case |
|---|---|---|
| Single tool native config | Directly use bundled models or custom APIs; fewer components to maintain | If built-in models and quotas are enough, start with this |
| CC Switch | Manage configs of multiple coding tools; some tools support local routing, aggregation, and failover | If the issue is scattered configs and you also want to manage MCP, Skills, and prompts together, this merits comparison; capabilities vary by tool |
| Claude Code Router(CCR) | Provide unified entry, routing, failure fallback, and request logs for multiple coding agents | If you need to control request routing and troubleshoot calls, it's an option; scope now covers more than just Claude Code |
| CLIProxyAPI | Expose supported CLI/account sources as a compatible API | Close to my account-reuse needs; must verify sources, protocols, and client entry points item by item |
| LiteLLM | Self-hosted unified API for routing, usage, virtual keys, and access control | Worth considering for multi-project or team unified management; virtual keys and other features require a database |
| New API | Self-hosted multi-channel gateway managing models, users, quotas, and costs | More relevant when serving multiple apps or users; requires maintaining the service and persistent data |
| Magpie | Manage agent model configs on desktop or CLI, connect sources via local gateway | Has the community plugins for WorkBuddy and Qoder needed this time; can start with my existing accounts |
These products overlap in features; you can't cleanly classify them into "modify config" versus "forward requests." CC Switch already has local routing; CCR already covers multiple agents. LiteLLM's database requirement depends on which features you use—see its virtual keys documentation.
My current use is personal; team permissions, cost allocation, and such aren't needed yet. Focus on connecting existing accounts and common tools first—don't jump straight into building a big platform.
4 Why I Chose Magpie
Magpie is free and open source, with a desktop app and CLI. I don't need to buy another subscription just to try it; its WorkBuddy and Qoder community plugins connect to the accounts I have. These two reasons are enough to install and see.
What I most want to use are the usage quotas in these accounts. Subscriptions are already paid for; check-ins and events add more. If some daily tasks can be offloaded to them, I can buy less extra usage. But these books have to be kept separate:
| Resource | How I plan to use it |
|---|---|
| Paid subscription | Continue using existing models and remaining quota in my favorite tool |
| Check-in points | Cover part of daily tasks like organizing notes, explaining scripts, based on supported models and multipliers |
| Time-limited gift quota | Use when suitable tasks come up and within the validity period; no artificial tasks just to beat the deadline |
Points can't be directly counted as tokens, and free quotas aren't unlimited. Which models can be called and which balance is deducted first depends on each provider's rules. Whether Magpie can connect the entry points is one thing; how much is saved is only calculable after actual use.
Per the getting started docs, first add model sources, then select models for agents; subscription login and requests are handled by the corresponding plugins. Next step: connect sources and tools, then handle check-ins, event quotas, and fallback. This log covers November 12–13, 2026, on an Apple Silicon Mac, with Magpie version 0.1.3853 at install time.
5 Full Integration Config: Connect Account Models to Common Tools
With so many names, it's easy to confuse "who provides the model" with "which tool uses it." First, distinguish these three roles:
| Object | Role Here | Examples |
|---|---|---|
| Model source (Provider) | Provides model calls and account quota | WorkBuddy, WorkBuddy AI, Qoder, Qoder CN, ZCode |
| Agent (tool) | Where I actually read projects, write code, organize materials | MiniMax Code, WorkBuddy, ZCode, etc. |
| Magpie | Connects sources, manages the model list, forwards requests, writes integration config for supported tools | Local gateway 127.0.0.1:3425 |
A name can appear on both sides. ZCode can provide models to other tools, and it can also use other providers' models as a tool. Connecting an account and connecting a tool are two different things.
The magpie ... commands below all run in the Mac terminal and are handled by Magpie, not typed into MiniMax Code's chat box. Daily model selection can still happen inside the app; no need to move work to the terminal just because of the gateway.
5.1 Install Desktop App and CLI
First run the official install script in the Mac terminal; it installs the Magpie desktop app and the magpie command:
curl -fsSL https://usemagpie.ai/install.sh | sh
The first direct connection never finished downloading. I interrupted with Ctrl-C and reran with my existing proxy, which succeeded:
curl -fsSL https://usemagpie.ai/install.sh | sh -s -- --proxy http://192.168.0.31:20172
This proxy was my existing network config; it's not a required address for installing Magpie.
Two things land: /Applications/magpie.app and ~/.local/bin/magpie. Open the app; the UI is in Chinese. The quick start suggests adding model sources, connecting agents, and setting up routing (routing is optional).
A macOS prompt also popped up: "magpie tried to access data from other apps and was blocked." I didn't grant extra permission; subsequent config reads and calls in the log still completed. From this prompt alone, I can't determine which specific access was blocked.
5.2 See Which Tools It Detected
magpie ls
This command lists tools Magpie detected locally, config locations, and current models. It does not start a model conversation. This machine detected 17 tools at the time, including MiniMax Code, ZCode, two WorkBuddy instances, two Qoder instances, and others.
When first opened, the selector mainly showed GPT models. Based on the login state and config at the time, Codex's 8 subscription models were discovered first. But I want to connect other accounts' models and quotas; tools being detected doesn't mean these sources are already connected.
5.3 Install Source Plugins, Log In with Existing Accounts
Installing source plugins here—not reinstalling the WorkBuddy or Qoder desktop apps:
magpie plugin add workbuddy
magpie plugin add qoder
ZCode source already showed logged in at the time; several others showed not signed in. Continue authorizing the needed sources:
magpie plugin login workbuddy
magpie plugin login workbuddy-ai
magpie plugin login qoder
magpie plugin login qoder-cn
What follows login is the model-providing source. Complete login via the browser or device authorization page, then check whether the corresponding source shows logged in. This step doesn't decide which model MiniMax Code uses.
WorkBuddy login hit a snag. I first chose "reuse desktop login state," which errorred: desktop 5.6+ stores credentials encrypted; Magpie can't reuse them and suggested browser login. Rerunning with browser login, using an existing session, completed authorization. WorkBuddy AI also went through the browser. Qoder and Qoder CN went through device authorization pages.
Initially recorded model counts: WorkBuddy 15, WorkBuddy AI 16, Qoder 17, Qoder CN 4, ZCode 4. These changed later as the catalog changed, so these were the numbers at that time, not fixed specs. QwenWork and the enterprise edition bundled with the Qoder plugin were not logged in, so I didn't count them as available sources.
Same model names can appear on different platforms. For example, MiniMax models are also offered by WorkBuddy AI; requests still go through WorkBuddy AI's account and usage. Same name doesn't mean shared balance.
5.4 Separate Configuration of Source Scope and Exposed Models
What I need is to aggregate specific models from several providers, not pull in every model from each account. There are two layers of restriction; missing either one skews the config.
First layer: decide which sources each tool can use. Each tool excludes its own corresponding source and Codex, keeping the other needed sources. ZCode doesn't re-list zcode/* for itself, but other tools must still access it.
Second layer: decide which models each source exposes. Each of the two WorkBuddy instances keeps only Hy3, Hy4, DeepSeek 4.1 Flash, GLM 5.3 Flash; each of the two Qoder instances keeps Qwen4-Max-Preview, Qwen3.8-Flash, DeepSeek-Flash, GLM-5.3-Flash, not exposing other models.
Per the actual display names in the catalog, here are the models I kept:
| Source | Exposed Models |
|---|---|
| WorkBuddy | Hy3, Hy4, DeepSeek-V4.1-Flash, GLM-5.3-Flash |
| WorkBuddy AI | Hy3, Hy4, DeepSeek-V4.1-Flash, GLM-5.3-Flash |
| Qoder | Qwen4-Max-Preview, Qwen3.8-Flash, DeepSeek-Flash, GLM-5.3-Flash |
| Qoder CN | Qwen4-Max-Preview, Qwen3.8-Flash, DeepSeek-Flash, GLM-5.3-Flash |
| ZCode | GLM-5.3, GLM-5.3-Flash, GLM-5.2, GLM-5-Turbo |
Tables use display names. In commands, qmodel_latest corresponds to Qwen4-Max-Preview, qfmodel to Qwen3.8-Flash, dfmodel to DeepSeek-Flash, gfmodel to GLM-5.3-Flash; these are the IDs used by the source interface, not additional models.
The Hy4 here refers to the hy4free entry labeled Hy4 in the catalog; hy4std and Hy3 X and other entries were not included. Both Qoder instances have qmodel_latest labeled Qwen4-Max-Preview, gfmodel as GLM-5.3-Flash, dfmodel as DeepSeek-Flash. I also verified the DeepSeek version later: both the international official docs and CN official docs explicitly state that DeepSeek-Flash in the selector corresponds to DeepSeek-V4.1-Flash-1017. So it's confirmed as the 1017 version of the 4.1 series, based on both parties' official naming, not by asking the model itself. Config and UI keep the source's actual dfmodel and DeepSeek-Flash names.
Qoder CN's catalog also needs refreshing: the local old catalog initially listed only Qwen3.8-Flash; the other three entries appeared only after synchronization. Qwen3.8-Flash can't substitute for the Qwen4 entry. Earlier quota queries showed its additional credits as 1600 / 1600 credits with 0 remaining, but the three entries in the list all returned the expected text in this round of item-by-item calls. This credit window doesn't represent all available benefits, and you can't infer from it alone that all models are uncallable; which benefit is deducted needs upstream usage detail confirmation.
The earlier misstep was here: I once disabled the entire ZCode source and missed it in other tools' whitelists; later I misread "keep other sources" as "open all models" and cleared model restrictions, which produced 58 models in MiniMax and 41 in WorkBuddy. Neither result matched my intended scope.
When fixing, I first kept a rollback copy, then wrote the model selection checklist per the table's IDs back into Magpie's saved selection, excluding each tool's own source. Source whitelist and model selection take effect together. For MiniMax Code, once the checklist was determined, Magpie ran:
magpie visible minimax-code zcode,workbuddy,workbuddy-ai,qoder,qoder-cn
magpie visible minimax-code --only-picked
magpie sync
The first line restricts sources; the second shows only models selected per the table to prevent other models or new entries from auto-creeping in; the third syncs the model catalog and writes model lists into each tool. --only-picked doesn't pick models for me; running it without first setting the checklist doesn't produce the table's scope.
A real discrepancy surfaced: the gateway list had narrowed, but the app config file still had the old full list. After syncing, I compared the tool config and the restarted UI to align both ends.
Final aggregated lists per tool, counts as of the November 13 check:
| Tool | Aggregated Model Count in Config | ZCode Models Among Them | Its Own Source / Codex |
|---|---|---|---|
| Claude Code | 20 | 4 | 0 / 0 |
| MiniMax Code | 20 | 4 | 0 / 0 |
| Qoder | 16 | 4 | 0 / 0 |
| Qoder CN | 16 | 4 | 0 / 0 |
| WorkBuddy | 16 | 4 | 0 / 0 |
| WorkBuddy AI | 16 | 4 | 0 / 0 |
| ZCode | 16 | 0 | 0 / 0 |
This table shows the current tool config and the gateway interface's restricted list. After both Qoder instances regained Qwen3.8-Flash, MiniMax Code is 20 and WorkBuddy is 16; GPT, Grok, Kimi, and other models from the two WorkBuddy instances were not included. The actual app chat verification below remains valid, but after restoring models this time, I didn't re-check the app menus; already-open tools need their lists reloaded.
Earlier, the running /v1/models had been missing Qoder CN's three entries, so MiniMax's corresponding interface had 15 and WorkBuddy 11, while the app config and menus showed 18 and 14. Checking the current gateway version 0.1.3958's catalog reading logic and the plugin change check, the CLI and desktop gateway each keep their own Provider in-memory snapshots. The gateway reads the existing snapshot first; a disk catalog update doesn't mean another process immediately switches to the new catalog. This matches the observed "files updated, running interface still old."
On further re-check, the running catalog had recovered. I then ran magpie sync once more, checked the IDs item by item, and confirmed the tool configs match the running gateway: after restoring Qwen3.8-Flash, MiniMax has 20, WorkBuddy 16, and both Qoder instances include all four entries. Other tools also match the table; own sources and Codex remain excluded. What was restored was catalog sync, not opening all models, nor modifying Magpie source code or restarting the gateway service. Which refresh event actually restored the old snapshot isn't recorded in logs, so I can't invent a definitive trigger.
What's filtered here is Magpie's aggregated list; I didn't remove app-native models. MiniMax's built-in M3, M3.1-Flash, and WorkBuddy's native menu remain. There's also no separate MiniMax source integration, so installing MiniMax Code doesn't mean MiniMax subscription is included.
5.5 First Confirm the Gateway Can Call Sources
After account login, I tested the gateway-to-source leg with a text request:
curl -s http://127.0.0.1:3425/v1/chat/completions \
-H "Authorization: Bearer magpie" \
-H "Content-Type: application/json" \
-d '{"model":"workbuddy-ai/deepseek-v4.1-flash-sg","messages":[{"role":"user","content":"你是什么模型?一句话回答"}]}'
This curl sends a request to the local Magpie, which then calls WorkBuddy AI's DeepSeek. It's a real call and may consume account quota. It's not a MiniMax Code message.
A reply came back, so this request had a result. A model claiming "I am X" can't serve as identity evidence; check the selected source, model ID, and call logs instead.
For the four models in the list, both sources completed real requests. Rows below use display names. Requests still use WorkBuddy's existing gateway identity.
| Model | Qoder | Qoder CN |
|---|---|---|
| Qwen4-Max-Preview | HTTP 200, MODEL_SCOPE_OK |
HTTP 200, MODEL_SCOPE_OK |
| Qwen3.8-Flash | HTTP 200, QWEN38_OK |
HTTP 200, QWEN38_OK |
| DeepSeek-Flash | HTTP 200, MODEL_SCOPE_OK |
HTTP 200, MODEL_SCOPE_OK |
| GLM-5.3-Flash | HTTP 200, MODEL_SCOPE_OK |
HTTP 200, MODEL_SCOPE_OK |
That's four per source, eight in total, all receiving the expected replies. These requests went from a script to the running gateway, not sent item by item in App chat boxes; actual UI send/receive verification for the two apps follows below. These results prove the listed entries can be called this time; they don't compare coding quality, long-session stability, or actual deduction. The hashes of the seven config files checked during the initial six calls didn't change. When restoring Qwen3.8-Flash, only the corresponding entries were added; no other models were opened temporarily for testing.
5.6 Selecting Aggregated Models in MiniMax Code and Sending Messages
In this step, MiniMax Code is the object being configured; Magpie does the configuration. On Magpie's Agents page, find MiniMax Code, select a model from those that are connected and visible to it, and Magpie writes the integration config. There's no separate "import MiniMax Code app" command.
The CLI can select models too. For MiniMax Code choosing GLM-5.3-Flash from WorkBuddy AI, the command:
magpie minimax-code workbuddy-ai/glm-5.3-flash
Break it down:
| Part | Meaning |
|---|---|
magpie |
Program performing the configuration |
minimax-code |
Agent being configured |
workbuddy-ai |
Source providing the model |
glm-5.3-flash |
Model ID selected this time |
Combined: "Use Magpie to select GLM-5.3-Flash from WorkBuddy AI for MiniMax Code." It changes current model config; it doesn't log into MiniMax subscription, import all models, or send a chat message immediately. This line explains the command parts; the actual UI verification used a ZCode model discussed later. I can still switch sources per task within the agreed model scope.
To see available options, use another read-only command:
magpie models minimax-code
Adding models queries the list; the earlier command changes the selection. Model IDs should be picked from the actual current list, not hardcoded from old records.
For the UI verification, I quit and reopened MiniMax Code, and in the Magpie group checked ZCode, both WorkBuddy, both Qoder models. No self-source and no Codex source were double-added. Current counts with Qwen3.8-Flash restored follow section 5.4, not the old UI counts.
For actual chat verification, I used ZCode's GLM-5.3-Flash, sent the verification message in the app chat box, and the UI replied:
MiniMax UI verification passed
The gateway log for that period also recorded agent: minimax-code, provider: zcode, model: GLM-5.3-Flash, status 200. After narrowing the exposed model list, I also restarted to re-check the UI entries; the same ZCode model remained. I didn't expand successful send/receive into "all other models also called successfully."
5.7 Using Other Sources in WorkBuddy
WorkBuddy's config file is ~/.workbuddy/models.json; WorkBuddy AI's is ~/.workbuddy-ai/models.json. Don't treat them as the same file just because the names are close.
Opening WorkBuddy fresh showed version 5.11.2. In the UI verification, I checked ZCode, WorkBuddy AI, Qoder, and Qoder CN models in the "custom models" area of the selector. This aggregated area contains no workbuddy/* or codex/*, and no models outside the list.
An actual message also used ZCode's GLM-5.3-Flash; sent from the chat box, the reply was:
WorkBuddy UI verification passed
The gateway log also shows ZCode as the source, status 200. So I can stay in WorkBuddy's UI while using a model from another account's provider, without switching to the ZCode app for this one message.
These two apps had actual menu checks and short ZCode message send/receive records. After restoring Qwen3.8-Flash, I verified config and gateway lists this time; the old app check wasn't treated as the new menu being accepted. Other models' one-by-one generation, project file read/write, tool calls, long-session stability, and code quality still need real tasks to assess; they can't all be considered passed together. Which quota was used this time is covered in the usage comparison below.
6 Additional Config: Other Entries, Check-ins, Event Quotas, and Fallback
The above connects sources and common tools. This part is as needed; not every tool needs connection, and not every account needs check-ins.
6.1 Qoder CN: Config Written, But IDE Native Chat Is Another Entry
Once the gateway replies, I also want it in the Qoder CN IDE I use daily for coding. First check in the terminal, then select WorkBuddy AI's DeepSeek for qoder-cn:
magpie qoder-cn
magpie qoder-cn workbuddy-ai/deepseek-v4.1-flash-sg
The executor is still Magpie; it modifies this agent's integration config in ~/.qoder-cn/settings.json. The providers.magpie entry does appear in the file, baseUrl points to http://127.0.0.1:3425/v1, and the model points to the corresponding pool entry.
But no Magpie entry appeared in the IDE model selector. Checking settings, the "add model" provider dropdown had only 7 presets: Alibaba Cloud Bailian, Qwen AI Platform, Zhipu, Kimi, MiniMax, DeepSeek, Xiaomi MiMo. No place to enter a local gateway baseUrl.
In the extension paths I checked, no logic was found that lets the IDE native chat read this local custom provider config. So what's confirmed here is that the config is written and Magpie can list models for qoder-cn; the Qoder CN IDE native chat integration is not yet confirmed. MiniMax Code and WorkBuddy's success can't vouch for it.
I didn't continue modifying the IDE. It's better to use the entries that work directly than to maintain a self-modified IDE just to unify entries.
6.2 Check-in for Supported Source Accounts
Of the "cyber eggs" I keep track of, check-in points count. Magpie can trigger check-ins for source accounts it supports, but "program support" and "my account automatically received it" are two different things. The log shows manual runs:
magpie accounts checkin
This asks Magpie to trigger check-in for supported source accounts—not to select models or send chat requests. Output shows WorkBuddy, Qoder, Qoder CN all already checked in that day, each +100 · already.
already is already received, not that running the command again adds another 100. These are historical check-in results; they don't prove every future day is auto-claimed. Points' validity, supported models, and deduction multipliers still follow each account's rules.
Per this install's features and plugins, auto-check-in also breaks down by source:
| Source | What Magpie supports |
|---|---|
| WorkBuddy | Current plugin has a check-in interface needing a valid account login; API key login can't check in this way |
| WorkBuddy AI | Current plugin doesn't provide check-in handling; can't extend WorkBuddy's auto-check-in conclusion |
| Qoder / Qoder CN | Plugin supports claiming daily event points, may depend on the original vendor's device helper; whether the day has an event and can be claimed depends on the returned result |
| MiniMax Code | Magpie has daily check-in already; needs a valid MiniMax Code account recognized and the corresponding check-in option enabled |
| ZCode | Plugin supports attempting to claim event packages; client-side security verification still requires the original client |
MiniMax Code is easy to conflate here: using ZCode models as a working tool is different from checking in with its own account. Magpie's feature log lists MiniMax Code daily check-in, but this read-only check found minimaxCheckin as false locally, and no successful MiniMax auto-claim record was verified, so it can't be written as "already auto-checking in."
Per Magpie's check-in mechanism docs, you need to enable check-in for the relevant source, keep the account valid, and let Magpie run during execution. Sleep, exit, or network failure means it won't guarantee arrival at the fixed time each day. The final arbiter is the claim result on the account card and the upstream balance, not whether the toggle is on. This time I didn't enable or modify these check-in options.
6.3 ZCode's Time-Limited Gift: Claimed, But Which Quota Applies at Call Time
The previous claim was "ZCODE GLOBAL BUILD." The client card showed 300 million GLM-5.3-Flash tokens retrievable daily, effective 23:00 that night, expiring 09:00 the next day. I manually claimed it in the Mac client and saw the "claim successful" popup.
On the night of November 13, another check revealed "ZCODE WEEKEND BUILD": 500 million tokens of GLM-5.3-Flash, effective November 13 at 23:00, expiring November 16 at 09:00. This one was also claimed in the ZCode client, with the popup clearly showing "claim successful." This and the daily gift above are two separate events; quota and validity can't be mixed.
This time I first checked why Magpie hadn't claimed it: the old login entry could read GLM Coding Lite usage but said there was no ZCode session, so it couldn't read the gift benefit. After attempting to reuse the client login state, the prompt persisted; only after redoing the BigModel ZCode official authorization did the pending weekend event show up. I also switched Magpie's ZCode current account to this valid login.
But having login doesn't mean auto-claim works. Actually invoking the installed plugin's claim logic returned outcome: "captcha", indicating the event requires ZCode client security verification; auto-claim is left to the client. Returning to ZCode and clicking "Claim" on the card finally produced the success popup. What's confirmed here is client-side claim success, not Magpie auto-claim success.
Claiming and having it deducted—again, two things. At the time of claiming, the weekend event hadn't reached 23:00 yet; the effective balance and actual consumption of the gift haven't been verified. The gateway call check done earlier can't prove this new quota has been used.
In the earlier ZCode gateway call check, I made three short requests in the afternoon, then sent UI messages in MiniMax Code and WorkBuddy. Before and after the first batch of short requests, I checked the gift package balance for the same login identity and ran magpie quota zcode --json:
| Check item | Before calls | After calls |
|---|---|---|
| Gift package balance endpoint | HTTP 200, business code 0; plans: [], balances: [] |
also empty |
| GLM Coding Lite 5-hour usage | 0 / 5000 |
1 / 5000 |
| GLM Coding Lite weekly usage | 2094 / 5000 |
2094 / 5000 |
The screenshot at the time was outside the event's valid window, so the endpoint returned no usable gift packages or balance, and the catalog had no corresponding -Trial entry; the Coding Plan 5-hour usage increased. So this confirms ZCode source calls succeeded and Coding Plan usage increased, but no gift quota consumption was verified. The afternoon UI replies can't be rewritten as "the gift quota was used."
The package units in the table also can't be taken directly as tokens; stats may lag, so you can't back-calculate how many units exactly three requests consumed. Whether the earlier gift was ever used can't be confirmed from the current historical detail either.
Per the installed ZCode community plugin, a valid gift package provides corresponding <model>-Trial entries. Actively selecting these restricts usage to the gift quota; rejection doesn't fall back to the Coding Plan. Normal models may attempt gift quota under "free first" settings, then fall back to subscription. So to verify gift consumption, compare gift bucket detail before and after a request inside the event validity period with confirmed account balance—not just request success.
So auto-check-in supporting gift plans doesn't mean every event can be claimed unattended; this weekend event explicitly required client handling. Recovering the source plugin wasn't a precondition for claiming either; the earlier disable/reenable was just recovery after a mis-scoped filter.
6.4 Using Points in Real Work Requires Counting App Context Overhead
With the entry points connected, I plan to use WorkBuddy check-in points for small tasks I'd do anyway: organizing notes, explaining a script, checking whether steps are missing. Not inventing tasks just to consume free quota.
While checking the DeepSeek version, I also confirmed: the DeepSeek-Flash free event mentioned in both Qoder official docs ended October 31, 2026 at 24:00; the CN page now marks it "ended." This log is from November 13, so the old event can't be used as evidence that it's still free today. What a model is called, whether it can be called now, and what rules apply today—those all need separate verification.
For example, organizing notes can stay in MiniMax Code, selecting workbuddy/glm-5.3-flash as the explicit source, giving it a raw command and context to explain parameters and reorder steps, which I then verify item by item. Don't swap in the similarly named workbuddy-ai/glm-5.3-flash; that's a different source and won't consume WorkBuddy's check-in points.
Before starting, check points balance, validity, and the model's deduction rules; after finishing, compare Magpie's source, model, time, and upstream usage changes. Whether upstream deducts gift points or paid balance first follows actual rules and detail. This work example hasn't completed the deduction check; it's an intended usage, not a record of points already saved.
The UI test also reminded me: a short message in an app isn't necessarily just one model request. MiniMax Code and WorkBuddy each sent one verification message, but the gateway logs for that period show:
| Tool | ZCode requests | Total input tokens | Total output tokens |
|---|---|---|---|
| WorkBuddy | 2 | 31,281 | 90 |
| MiniMax Code | 3 | 40,729 | 147 |
These are gateway log usage, not upstream final billing. The app may attach system prompts, tool definitions, or send auxiliary requests like session naming; this time I didn't break down each one, so I can't assign a purpose per request. A short terminal request with only a dozen input tokens indeed can't estimate an app's actual consumption.
So I care more about what a quota can actually accomplish and how much rework it produces. For complex bug fixes, project understanding, tool calls, and fix verification all matter. The quota may be free, but fixing bad code is costly.
6.5 Keep Only ZCode and MiniMax Code Daily—Can the Other Apps Be Uninstalled?
I habitually use ZCode most, with MiniMax Code as a second working entry. That reduces open windows, but Magpie itself must remain installed and running; otherwise the two tools can't reach its aggregated sources.
As for the other apps, it depends on whether Magpie uses independent login states or reads credentials from the original apps each time. Current integration on this machine:
| App | Current dependency and trade-off |
|---|---|
| WorkBuddy / WorkBuddy AI | Both are Magpie-maintained OAuth login states, not read-from-desktop login files each time. Model calls generally don't require keeping or running their desktop apps, so these are prime uninstall candidates; but re-login, renewal, and calls after uninstall haven't been re-verified |
| Qoder / Qoder CN desktop | Current login state also lives in Magpie. Normal calls don't need the desktop app running, but check-in uses the vendor's runtime-info device helper; both CLI directories on this machine contain the helper as a find candidate, but check-in after uninstalling the desktop app is still unverified |
| ZCode | Source is marked as reading ZCode app login state, and event packages may need the client-side CAPTCHA pass. Since it's already the primary entry, keep it |
| MiniMax Code | Keep as a working entry. Its own login and check-in are separate from selecting other sources' models via the gateway |
"Slimming down" here means the app binaries first; user data isn't cleared along with them. ~/.config/magpie stores sources and login info, ~/.qoder and ~/.qoder-cn hold CLI helpers, and other directories may store sessions, attachments, and artifacts. You can't "uninstall and clean all remnants" and carry these away together. Also don't equate "quit the app" with "log out of the account."
So keeping only two working UIs is conditionally feasible, but deleting the other apps isn't guaranteed to have zero impact right now. Whether calls depend on the original app and whether check-in depends on the vendor's helper are two separate checks. Before uninstalling, keep reinstall conditions and data copies, then remove app binaries in batches, verifying calls, login renewal, and claiming. This log hasn't completed that post-uninstall verification set, and no apps have actually been deleted.
6.6 When Rollback Is Needed, Restore the Tool's Native Model Config
Using qoder-cn as an example: if Magpie should no longer manage its model config, let Magpie run:
magpie qoder-cn default
The object being modified is this agent's model config, not uninstalling the Qoder CN IDE or deleting chat history. This is saved as a rollback note; not executed this time.
7 After All This
The tangible gain so far: fewer switches between working entry points, and accounts no longer sit idle just because I moved tools. I still lean on ZCode for daily work, MiniMax Code as the second entry. Whether other apps can be slimmed down depends on the dependency checks above.
Both Qoder catalogs are now aligned; all eight items in the list returned replies with item-by-item calls. DeepSeek-Flash's official version is confirmed as V4.1-Flash-1017. However, the Qoder CN IDE native chat is not connected because of this; full work tasks haven't been tested one by one; ZCode's event gift consumption hasn't been verified. Being able to select and reply one line is still a distance from long-term stable work.
MiniMax Code's check-in can also go to Magpie. It supports daily check-in for logged-in MiniMax Code accounts, requiring the corresponding check-in option enabled and Magpie running. That removes one daily "open the app and tap" chore. But this machine hasn't enabled it yet, and there are no successful auto-claim records; noting the feature without claiming points arrive daily automatically. Check-in earns benefits in MiniMax Code's own account, separate from selecting ZCode or other sources' models within it.
One more thing to be clear about: account-ban risk. Being able to connect doesn't mean the platform permits this usage. Qoder official docs have clear restrictions on unauthorized service relay and similar usage; suspected violations may lead to access adjustments, and confirmed violations may suspend or terminate service. So the risk is more than one online reminder from a public account; it's not safe just because it's personal use and this request succeeded. Whether other sources allow this kind of integration needs checking against each's rules.
This log records how I set it up and what actually worked, not platform authorization. It can't guarantee accounts won't be restricted later. Self-service means bearing the results. Free is tempting, but staking accounts and real work on it isn't worth it.