The technical brief
What Quotum reads on your Mac
An app that reads your Keychain and your credential files should say which ones, what for, and where the result goes. This page names every source, every address and every schedule — and gives the commands that let you prove it wrong.
Survey dated October 11, 2026, made by reading Quotum's code as of that date. The line numbers cited shift with the first commit that adds a line above them; the classification holds. The commands in section 06 are there so that you can check it rather than take our word for it.
01 What it shows, line by line
A bare percentage is ambiguous. So each account in the panel shows, to the right of its name, the age of its measurement — because a figure measured three hours ago is not worth a figure measured just now; on an account folded under “Recharging”, that age shows on hover and to VoiceOver —, then one line per quota window that its provider publishes: the length of the window, a ten-box gauge whose filled cells show what is left, the share used, and the time at which it recharges.
All of an account's windows are written on its card. The shortest one it publishes takes the first line, in large type — 5 hours for Claude, 5 hours or 7 days for Codex depending on the plan, the month for Cursor —, and the others follow, more discreetly. No window is made up: a provider that publishes only one has only one line. The recharge time is written in its shortest form: the time alone within the day, preceded by the day up to six days ahead, the date beyond that.
Below its windows, an account can also carry a money line: an amount that the tool publishes itself, such as “Credits: €25.74 of €170.00 this month” for Claude, “On demand” spend for Cursor or Grok, or the credit balance for Codex. A limit specific to one model — for Claude, “Fable” — is written apart, its name on its own line above its 7-day gauge: it drives neither the menu bar nor the alerts, because an exhausted model does not stop the account from working with the others. It only moves up to the account's row if it will block before the account does, or if fewer than five of its ten cells are full; otherwise, it is read in the drawer. These amounts stay on this Mac, and never go to the publisher.
| Account | Window | Gauge | What is written |
|---|---|---|---|
| Travail · Max20 | 5 h | 22% used · 11:41 The short window, in large type, on the account's card. |
|
| Travail · Max20 | 7 d | 74% used · Sat 09:01 A longer window, on the same card, more discreet. Less than half of it is left: the gauge turns amber. |
|
| Perso · Max20 | 5 h | 91% used · in 25 min A single cell: ember red. The age, “measured 2 h ago”, is set in a heavier weight: past one hour, it is the figure most likely to have changed. |
|
| Veille · Max20 | 5 h | exhausted until 10:21 No filled cell, red outline: that is what “exhausted” means, not an invented value. |
|
| Équipe · Team | — | — | No measurement yet No gauge at all. An empty gauge would announce an account that has run dry, and nobody has observed that. |
An account whose token has expired shows “Sign in again” under its name, with no gauge: an expired token says nothing about the quota, and the account may be full. An account refused for quota with no window published, on the other hand, keeps an empty gauge, with no length, and “exhausted”, with the return time written under its name: without that gauge, the emptiest account would pass for an account never measured.
02 What it reads on disk and in the Keychain
Quotum asks you for no password and signs in to nothing. It reads back the credentials that the command-line tools have already placed on the machine, each where its own tool keeps it.
| Tool | Where the credential is read |
|---|---|
| Claude | Keychain, item |
| Warp | Keychain, items |
| Codex | Every Codex |
| Windsurf |
|
| Cursor | Cursor's |
| Codebuff |
|
| Augment |
|
| opencode |
|
| Grok |
|
| Grok Bot | The same token as Cursor — the Cursor editor's |
| GitHub Copilot | The |
| Kiro |
|
| Cline |
|
| Kimi Code |
|
| Kilo Code |
|
| Nous Portal |
|
| JetBrains AI |
|
| Factory Droid |
|
| Muse Code |
|
A check that opens nothing, before any tracking
To tell you whether a tool has left its sign-in on this Mac, the “Add an account” sheet
only checks that these files exist, without opening them, before you even
turn tracking on: ~/.local/share/devin/credentials.toml,
~/Library/Application Support/Windsurf/User/globalStorage/state.vscdb,
~/Library/Application Support/Devin/User/globalStorage/state.vscdb,
~/Library/Application Support/Cursor/User/globalStorage/state.vscdb,
~/Library/Application Support/Grok Bot/sand-secrets.json,
~/.config/manicode/credentials.json, ~/.augment/session.json,
~/.local/share/opencode/auth.json, ~/.grok/auth.json,
~/.config/gh/hosts.yml, ~/.aws/sso/cache/kiro-auth-token.json,
~/.cline/data/settings/providers.json, ~/.kimi-code/credentials/kimi-code.json,
~/.local/share/kilo/auth.json, ~/.hermes, ~/.factory and
~/.config/muse/auth.json — or wherever
$XDG_DATA_HOME, $GROK_AUTH_PATH, $GROK_HOME, $GH_CONFIG_DIR,
$XDG_CONFIG_HOME, $CLINE_PROVIDER_SETTINGS_PATH, $CLINE_DATA_DIR,
$CLINE_DIR, $KIMI_CODE_HOME, $HERMES_HOME and $MUSE_AUTH_PATH
move them. For JetBrains AI and the four tools it launches, it looks at nothing: only a
measurement will tell whether an account is there. For Z.ai and MiniMax, it only looks at
whether a key is already saved in Quotum's own Keychain item, without reading the key.
It also looks at whether the GROK_DEPLOYMENT_KEY variable is set, without keeping
or sending its value. No content is read, the Keychain is queried only for that Quotum item, and nothing goes out
over the network. A file being there therefore does not mean the sign-in is still valid: only
a measurement, once the tool is tracked, lets Quotum call an account signed in.
One exception, for Claude and Codex only: the sheet then opens the files that say which account
each app is signed in to — see “What “Add an account” reads and does”, below.
Four tools it launches, without reading their sign-in
Antigravity, Doubao, Alibaba Model Studio and Amp are not read: Quotum launches their official command-line tool, the one you installed and signed in to yourself, to have it print its quota. It is the tool that queries its server, with its own sign-in; Quotum reads none of it and sends no request of its own for them. Nothing is launched until the tool is tracked.
| Tool | What is launched |
|---|---|
| Antigravity |
|
| Doubao |
|
| Alibaba Model Studio |
|
| Amp |
|
At every launch, without exception: an absolute path taken from this closed list, never from
your PATH; a file owned by you or by the system, that nobody else can modify, and
whose real path, links resolved, stays under ~/.local, ~/.amp,
/opt/homebrew or /usr/local; never a shell, fixed arguments; an
environment built by hand, inheriting nothing from the app — no PATH, no proxy, no
token —, with NO_COLOR=1 and TERM=dumb; an empty, private working
folder, deleted afterwards; no input, output capped at 256 KiB, and ten seconds at most before
the tool and its children are stopped. Tools published on npm are scripts that ask for
node: Quotum only looks for it at /opt/homebrew/bin/node,
/usr/local/bin/node or ~/.local/bin/node, checked the same way, and puts
its folder alone at the head of the tool's PATH. Without an accepted
node, nothing is launched.
Two tools tracked with a key you paste
Z.ai and MiniMax are not read from disk: Quotum reads no other tool's credentials for
them. You paste a key yourself in the “Add an account” sheet — an API key for Z.ai, a
Token Plan subscription key for MiniMax —, with the account's region. Quotum keeps it in its own
Keychain item (below), reads it again at each measurement and sends it only to the tool's quota
server, at the address of the chosen region: api.z.ai or
open.bigmodel.cn for Z.ai, www.minimax.io or
api.minimaxi.com for MiniMax. ⚠️ This key can also spend with the
provider: Quotum uses it only to read the quota. No request goes out for them without the tool tracked and a key pasted; removing the key deletes its item and stops tracking.
And six sources read without any tool being tracked
These do not depend on tracking a tool: Quotum reads them at every measurement, whether tools are tracked or not, including on a fresh installation. None of them is used to query a provider.
~/.claude.json— theoauthAccountobject, which names the account signed in to Claude Code. It holds no token: it is used to place the Keychain measurement on the right line.~/.claude/cc-proxy.url,~/.claude/cc-proxy.secretand their~/.codex-comptes/equivalents — where to reach the local proxies, when they are installed. The secret file is itself an identifier: Quotum puts it in the path of the address it queries, and only sends it over your machine's loopback interface.~/Applicationsand Chrome'sLocal Statefile — which account apps exist, and which browser profile each one is attached to.ps -axo command— which of those apps are running right now, so as to write “Switch to the app” rather than “Launch the app”.<app data>/plan-usage-history.json— the usage history that Claude Code writes itself next to its configuration. It holds no token.<CODEX_HOME>/sessions/YYYY/MM/DD/rollout-*.jsonland, for an account held by a localcodex-proxy,<codexHome>/sessions/…in the folder it publishes, of which only the first line is read — the Codex CLI session logs, of which Quotum reads, at every measurement, only the end, looking for the quota headers the server left there — and only the first line to offer pinning, as stated below. ⚠️ These files are the transcripts of your sessions: we open them to look for a percentage, and for the working folder written on their first line; nothing from them leaves the machine, and we would rather tell you so than keep quiet about it because they hold no token.
To these is added one read made at launch only, so that a single copy of Quotum
runs: it places a system lock on its own folder,
~/Library/Application Support/Quotum/, without writing any file there, and, if
another copy already holds it, reads the list of open applications that carry Quotum's
identifier to bring that copy to the front, then quits. Nothing is written, nothing is sent.
What “Add an account” reads and does
When you open the “Add an account” sheet for Claude or for Codex, Quotum reads, on that action
and whether or not a tool is tracked — outside the choice of tracked tools —,
~/.claude.json (or $CLAUDE_CONFIG_DIR/.claude.json; already read above), ~/.codex/auth.json (or
$CODEX_HOME/auth.json; measurement, for its part, reads every Codex auth.json it knows, the same folder only once), and, in the data folder of each account app,
claude/.claude.json and codex/auth.json
(<data folder>/claude/.claude.json,
<data folder>/codex/auth.json — or, if the app's launcher declares another folder through CLAUDE_CONFIG_DIR or CODEX_HOME, the file in that folder, wherever it is). It keeps only the account's address and what identifies it — for Claude, its organization's ID and name; for Codex, the email claim of the id_token, read without checking its
signature, and the account ID that the tokens prove. Nothing is sent, nothing is copied. The sheet also reads, in each folder's config.toml, the same keys cli_auth_credentials_store, secret_auth_storage and profile; if they store the Codex sign-in in the Keychain, the address is read from the Codex Auth item, only if Codex is tracked — otherwise the sheet says the address cannot be checked, and never takes it from an auth.json left over from before. At auto, an auth.json counts only once the item is found missing; an encrypted sign-in or an uncertain config.toml also leaves the address unchecked. These
reads serve to show which account is already signed in — the account of the Claude app installed
as is remains the first account, never duplicated —, to refuse linking the same address twice,
and to check that an account app you have just created is signed in to the address you entered:
the disk is then looked at every 3 seconds, for 10 minutes at most.
This is an exception to a rule kept everywhere else: as long as a tool is not tracked, Quotum does not open the place where it keeps its sign-in — except here. For Codex, the file opened is indeed the sign-in file, tokens included; only the account's address and ID are kept from it.
The assistant then creates the account app, ~/Applications/<account>.app, and
its configuration folder, in 0700. It never receives your password: signing in happens in the
app itself. If you ask, and after you confirm, Quotum moves that app and that folder to the
Trash, and removes from its preferences the account's setting and its Chrome attachment; the
Chrome profile and the tool's own app stay.
A Chrome profile, on your action. When you choose “Create Chrome Profile” in the
assistant, or in the drawer of an account that has none, Quotum runs
open -n -a "Google Chrome" --args --profile-directory="Profile N": it is Chrome that
creates a new profile itself (folder …/Google/Chrome/Profile N) and opens it — the
--profile-directory argument only names that folder. Quotum itself modifies no
Chrome file. It only remembers, in its preferences, under the rattachementsChrome
key, the folder of that profile for that account: the folder and not the name, so that renaming
the profile in Chrome undoes nothing.
To offer “Pin my terminal here” with the last conversation of the right project
resumed, Quotum looks only at the names of the folders and files in Claude
Code's projects/ folder (<configuration folder>/projects/), never
their content. A working folder longer than 200 characters is recognized there only by the start
of its name, and only if a single folder matches; otherwise no conversation is resumed. For
Codex, it reads only the first line of each session file
(<CODEX_HOME>/sessions/YYYY/MM/DD/rollout-*.jsonl, or, for an account held by a local codex-proxy, <codexHome>/sessions/… in the folder it publishes for that account, accepted only if it is a real folder inside your home folder, with no link), 64 KiB at most, to read
the session's working folder and the ID that resumes it; only sessions opened in the terminal or in the editor, the ones Codex resumes itself, are kept, the most recently modified first, and reading stops at the 512-byte block that holds the first line break: what follows that break, 511 bytes at most, is discarded without being examined.
Nothing else from them is kept, and nothing is sent. It also looks for the
claude or codex program in your PATH and in usual folders
(~/.local/bin, /opt/homebrew/bin, /usr/local/bin…).
Reopening the account apps, if you turn it on. The
“Reopen my accounts' apps at login” setting, in Settings → General, is off by
default. When it is on, it reopens, hidden (open -n -g -j), the account
apps that are not running, so that their measurements resume, each time Quotum starts within
3 minutes of logging in — whether the login launched it or you did: what counts is when it
starts. Their script is never run, and
account 1 is not concerned.
Finally, the preferences remember the notifications already sent, so as not to repeat them:
notifications.propositions for reset proposals, 64 at most, and
notifications.argent for spending alerts, 256 at most.
What it writes to the Keychain
Three services, which it creates itself, and under them one item per source or tool you save — one to six items depending on what you paste. The first, “Quotum — trial”, service
app.quotum.mac.essai; its name follows the language of the app when it is created (“Quotum — essai” in French), the service does not change. It holds the start date of the trial and the 32-byte code,
drawn at random, that opens it, and nothing else; it is not synced with iCloud, and it stays
after the app is deleted, so that erasing the preferences does not restart the trial.
Deleting it as well as the preferences does not restart it either: the mark that Apple keeps
for this Mac prevents it — section 05.
The second, “Quotum — read-only key”, service app.quotum.mac.cle-lecture, exists only
if you paste a read-only key: a Claude Enterprise admin key that you create
yourself, with the single read:spend_limits permission, so that Quotum can read
your spend for the month and your limit. It holds that key and the ID of the member followed,
never in the preferences; the key goes nowhere but api.anthropic.com, and removing
the key deletes the item. Quotum refuses any key that does not have the form of a Claude
Enterprise key, never makes a call that generates a response, and cannot check that a key
carries no other permission: they are chosen when the key is created.
The same service holds, under another account name, an AWS or Azure read-only
identity, only if you paste one, to read the spend of a cost budget. For AWS: the ID of
an IAM user's access key (AKIA…) and its secret key; temporary credentials
(ASIA…) are refused, and the identity is asked of
sts.<region>.amazonaws.com before every read: the account's root user is
refused. Requests are signed on this Mac (AWS Signature Version 4): the secret key never
leaves, only a signature does, to sts.<region>.amazonaws.com and
budgets.amazonaws.com — never to Cost Explorer, where every request is billed. For
Azure: the client secret of an Entra ID application; it goes nowhere but
login.microsoftonline.com, which returns a token kept in memory for the length of
one measurement, then Quotum reads that application's permissions on the subscription at
management.azure.com and refuses any action that is not a read — before reading a
single budget. Neither can call a model. Quotum cannot check that an AWS identity has no other
rights: they are chosen when it is created. Removing the identity deletes its item. No item
belonging to another tool is written or modified.
The third, service app.quotum.mac.cle-outil, exists only if you paste a Z.ai or
MiniMax key: one item per tool, “Quotum — Z.ai key” or “Quotum — MiniMax key”. The key is in the
item's data, never in the preferences; the account's region and an identifier drawn at random at
each save are in its attributes, read without authorization. Just before sending, then before
showing the answer, Quotum checks that the tool is still tracked and that the key has not been
replaced: otherwise nothing goes out, or the answer is set aside. Removing the key deletes the
item.
The token only passes through. It is read, placed in the header of a
request, and nothing more: it is not copied into any file, written to any log or kept in
any cache. The network session is declared ephemeral, its cache is set to
nil and its policy ignores any local cache — which one command can confirm,
section 06.
03 Where it connects — every address, listed
The command grep -rn 'https\?://' Sources/ returns every line of the source code
that contains an address. They are all listed below, sorted into three groups.
We deliberately do not give their number: a count frozen on a page would be
out of date at the first commit, whereas a list can be compared line by line. An address you
found that was in none of the three tables would be exactly what to report to us.
A · The lines where the app connects by itself
| Line | Address | What happens there |
|---|---|---|
| QuotaAnthropic.swift:153 | https://api.anthropic.com | The quota windows of the Claude account, and the profile that names it. And, only if you have pasted a read-only key, your spend for the month and your Claude Enterprise limit: |
| QuotaCodex.swift:86 | https://chatgpt.com | The quota window of the ChatGPT account. And, on your gesture alone — when you open an account's drawer —, three reads under this host, with that account's sign-in and under the Codex consent: |
| QuotaCodexJetonPersonnel.swift:28 | https://auth.openai.com | Only for a Codex account signed in with a personal access token: the account identity, before its quota window on chatgpt.com. These two requests present themselves as the official Codex CLI, Quotum's only exception to that rule. |
| QuotaWindsurf.swift:59 | https://server.codeium.com | The Windsurf quota. The host may come from the user's file; it is then only accepted under |
| QuotaCursor.swift:311 | https://cursor.com | Cursor's monthly cycle and its on-demand spend. |
| QuotaWarp.swift:197 | https://app.warp.dev/graphql/v2 | Warp's cycle. |
| QuotaCodebuff.swift:138 | https://www.codebuff.com | Codebuff's five-hour block and week. |
| QuotaOpencode.swift:153 | https://opencode.ai | opencode usage. |
| QuotaGrok.swift:251 | https://cli-chat-proxy.grok.com | Grok credits. |
| QuotaGrokBot.swift:49 | https://api2.cursor.sh | Grok Bot’s weekly allowance, on the Cursor account. |
| QuotaCopilot.swift:270 | https://api.github.com | GitHub Copilot's monthly allowance of premium requests, through a route GitHub does not document. |
| QuotaKiro.swift:162 | amazonaws.com/getUsageLimits | Kiro credits, on |
| QuotaKimi.swift:160 | https://api.kimi.com | Kimi Code's 5-hour, 7-day and monthly windows, with the token the |
| QuotaClinePass.swift:195 | https://api.cline.bot | The windows of the ClinePass subscription, through a route Cline does not document. |
| QuotaKilo.swift:178 | https://app.kilo.ai | The Kilo Pass period, through a |
| QuotaNous.swift:73, 172, 291 | portal.nousresearch.com · https://\(hote) | Nous Portal's monthly allowance. The portal can come from the Hermes file; it is then accepted only over |
| QuotaMuse.swift:264 | https://api.meta.ai | Muse Code's quota. ⚠️ This route creates a key on your Meta account at every call: its answer is what carries the quota. Quotum calls it at most every fifteen minutes, does not use the key created and does not keep it — section 05. |
| QuotaZai.swift:73, 74 | https://api.z.ai · https://open.bigmodel.cn | Only if you have pasted a Z.ai key: the windows of its coding plan, at the address of the account's region — no other is accepted. Neither the key nor the region comes from another tool. |
| QuotaMiniMax.swift:76, 77 | https://www.minimax.io · https://api.minimaxi.com | Only if you have pasted a MiniMax subscription key: the windows of its Token Plan, per model, at the address of the account's region — no other is accepted. |
| QuotaFactory.swift:366, 367 | factory.ai/api/billing/limits | Factory (droid) windows, on |
| DepenseAWS.swift:106, 114 | https://budgets.amazonaws.com · https://sts. | Only if you have pasted an AWS read-only identity: |
| DepenseAzure.swift:83, 84, 87 | https://login.microsoftonline.com · https://management.azure.com | Only if you have pasted an Azure read-only identity: the application's token, then its permissions on the subscription — a single action that is not a read, and nothing else goes out —, then its budgets. A next page is followed only on |
| LecteurProxy.swift:17 | http://127.0.0.1:8787 | The status of the Claude proxy, on your own machine. It never leaves the computer. |
| LecteurProxy.swift:25 | http://127.0.0.1:8788 | The status of the Codex proxy, likewise. |
| AdressesLicences.swift:9 | https://licences.quotum.app | The publisher's license service, with two routes: |
| AdressesLicences.swift:5 | https://quotum-licences-test.brickback.workers.dev | The same service in test mode. This line only exists in the program if it is compiled with the |
The two loopback ports cannot become anything else. Their address is read
from a file on disk, and nothing in the format of a URL would stop that line from naming a
remote machine. So the code accepts only three spellings — 127.0.0.1,
::1, localhost — and rejects everything else without having to
imagine it. It is a list of what is allowed, not a list of what is forbidden: a list of
that kind would always let through the form nobody had thought of.
B · The lines a browser opens, and that the app never queries
These are the destinations of commands such as “Open claude.ai” and “Open cursor.com”. They go to the browser you have chosen. Quotum sends them no request and reads nothing of what they return.
| Lines | Addresses | What happens there |
|---|---|---|
| Compte.swift:64, 65, 69–75, 78–93 | claude.ai · chatgpt.com · devin.ai · cursor.com · app.warp.dev · www.codebuff.com · augmentcode.com · opencode.ai · grok.com · github.com/copilot · kiro.dev · cline.bot · www.kimi.com · kilo.ai · portal.nousresearch.com · www.jetbrains.com/ai · app.factory.ai · www.meta.ai · antigravity.google · www.volcengine.com · modelstudio.console.alibabacloud.com · ampcode.com · z.ai · www.minimax.io | Each tool's home page, one per provider. |
| Compte.swift:190, 191 | claude.ai/download · chatgpt.com/download | Where to get the desktop app, offered when it is not installed. |
| Actions.swift:215 | claude.ai/settings/usage | Claude's Usage page, offered on a Claude account's row. Your browser opens it, in that account's profile; Quotum never queries it. |
| VueFinEssai.swift:13, 14 | quotum.app/fr/achat · quotum.app/pricing | This site's purchase page, in French if the app speaks French to you, in English in any other language. The button that offers it, at the end of the trial, opens it in your default browser. |
C · The lines that are not destinations
| Lines | Text | What it is |
|---|---|---|
| VueReglages.swift:839 | https://exemple.test | A throwaway URL, never opened: it is used to ask macOS which browsers are installed, to fill the menu in the settings. The |
| QuotaGrok.swift:91, 93, 105 | https://auth.x.ai::… · https://accounts.x.ai/sign-in | OAuth scopes, that is, labels compared with those in the local file to tell which sign-in a token comes from. They look like addresses; none of them is contacted. |
| IdentifiantsCodex.swift:163 | https://api.openai.com/auth | The name of a section inside the Codex token, read on the machine: it is where the token names the account it belongs to. A label shaped like an address; no request goes there. |
| QuotaAugment.swift:9, 160, 161 | in comments | Documentation: the form of the tenant address, and the trailing-slash pitfall measured while writing it. |
| QuotaWindsurf.swift:343 | in a comment | An attack counterexample, cited to explain why checking only the scheme of a URL is not enough. |
| CommandesInstallation.swift:9, 10 | https://claude.ai/install.sh · https://chatgpt.com/codex/install.sh | The official installers of Claude Code and Codex. Each one is a command to copy, shown on the welcome screen when no session is found on the Mac: Quotum never runs it. You paste it into Terminal yourself, and it is the command, not the app, that contacts the publisher. |
A destination this command does not show
Augment. Its address is written nowhere in the code: it is read from
~/.augment/session.json, in the form
https://<tenant>.api.augmentcode.com, and is only accepted if it stays
under the augmentcode.com domain. A grep for addresses therefore
cannot bring it up — and that is why we give you this list instead of letting you conclude
that one command is enough to establish everything.
04 How often
A measurement cycle starts when the app launches, each time the panel opens, when you ask
for a refresh, after an account is created, when you change the tools you track, and when a shortcut or a script on this Mac asks for it through quotum://open or quotum://refresh, at most once every 30 seconds — then
every five minutes. That interval can be set in the settings to one, five or fifteen
minutes; it does not go below one minute, out of restraint and not because any provider
would require it.
Automatic measurements are five minutes apart by default; you can choose one or fifteen minutes. They space themselves out, up to thirty minutes (or your setting if it is longer), when the Mac is idle, in Low Power Mode or offline. To know whether the Mac is idle, Quotum asks macOS only for the time elapsed since the last keyboard, mouse or trackpad action, never the action itself.
And no tool is queried as long as you track none. None of the twenty-five is tracked at installation, and each one is chosen separately: at installation, no token is read and no request goes to any provider. Only the update check and the request that opens the trial at first launch, which do not depend on that choice, and, once per Mac after purchase, the license activation, reach the publisher's server — section 05. What follows therefore describes the cycle of a tool you have chosen to track.
A cycle, at most, is:
- two requests to
api.anthropic.com— usage and profile, sent together; - one request to each of the eighteen other providers that Quotum queries itself — for Z.ai and MiniMax, only if you have pasted their key;
- one request to
api.meta.aifor Muse Code, at most every fifteen minutes, whatever the interval chosen; - one launch, read-only, of the command-line tool of each of the four launched tools — two for Antigravity, its version then its quota, and two for Alibaba Model Studio when the first console measured nothing;
- no request for JetBrains AI, which is read from a file;
- one more request to
api.anthropic.com, for spend, if you have pasted a read-only key; - two requests to AWS — who is signing, then the budget — if you have pasted an AWS read-only identity, and three to Azure — the token, the permissions, then the budget — if you have pasted one for Azure;
- two reads over the loopback interface, which do not leave the computer.
“At most” is the key phrase. Each reader first looks for its credential on the machine, and only goes out to the network if it found one. On a computer where Cursor is not installed, no request goes to Cursor — not an empty request, not a call that fails: nothing. The same holds when the Keychain is locked or a read is blocked. A setup with two tools therefore makes two or three requests per cycle, not twenty-five.
Outside this cycle, and on your gesture alone: when you open the drawer of a
Codex account, one request to chatgpt.com for its reserve of resets, then five
pages of history at most, and one for its day-by-day usage. Never at each cycle, and nothing while Codex is not tracked.
05 What never leaves your Mac
None of your measurements, none of your account names and none of your tokens are sent to Quotum's publisher. There is no account to create, no analytics in the app — the website's own is described in the legal notice —, and no automatic crash report. What the app measures stays on the machine that measured it.
Two local copies, on this Mac only. The first, only if you ask for it: if you turn it on, Quotum writes the state of
your quotas — displayed names (hidden if you asked for it), percentages, reset times, no token
or address — to ~/Library/Application Support/Quotum/status.json, on this Mac only,
and deletes it when you turn it off; off by default, the file is created in 0600, in a folder brought back to 0700, and each account carries an HMAC identifier derived from a random 32-byte salt, kept in the sortie.sel preference.
The second, with no setting, for the desktop widget: as soon as the application carries the
widget, whether or not a widget is placed, Quotum writes the same state — plus the tool or
cloud of each account, to display its logo — to
~/Library/Group Containers/BSV88JY7M9.app.quotum.mac/instantane.json, in 0600.
Only the widget reads it, and it has no network access. macOS also creates the widget's own
folder, ~/Library/Containers/app.quotum.mac.widget, where Quotum writes nothing.
Three exceptions, and they are real. Quotum checks the publisher's update feed to find out whether a newer version exists — that is what allows a copy already installed to be told about it. Nothing else goes back that way: no account, no measurement, no statistics. At first launch, it opens the trial. And, once per Mac after purchase, it activates the license. The two subsections below describe these last two. Writing “there is no publisher server” would be false, and we do not write it.
The trial, opened by Apple
At first launch, Quotum sends a request to licences.quotum.app/essai: a code
drawn at random on this Mac, and a token that Apple issues to this Mac through DeviceCheck,
an Apple service — short-lived, single-use, and readable only by Apple. Nothing else: no
serial number, no machine name, no measurement. The code is 32 bytes long; it is written to
the preferences and to the “Quotum — trial” item before the request goes out. The request
carries no cookie and follows no redirect. The license service passes the token on to Apple,
which keeps for each Mac the mark of a trial already granted; if the mark is absent, the
service sets it and returns a signed ticket, then verified on this Mac, offline: no further
request for the trial. If the mark is already set, the trial does not open. If the service
does not respond, the same request goes out again on its own one minute later, then at
doubling intervals, six hours at most, as long as trial time remains; in the meantime, no
account is measured. Without Apple's answer, there is no trial. In a virtual machine, where
DeviceCheck does not exist, nothing goes out.
The code for this request is not published: it belongs to the trial mechanism, which the
verification repository keeps private. What it carries can still be checked there, in
Tests/QuotumTests/GardesReseauTests.swift, which builds it with the real code and
fails if a header or a field is added. What the service keeps from it — the SHA-256 hash of the code, never the code itself, and two
dates, for thirty days, without your IP address — is set out in the
privacy policy.
Activation, once per Mac
When you choose “Activate This Mac”, Quotum sends a single request, to
licences.quotum.app/activer: your license key, the public half of a key that this
Mac's security chip creates for the occasion, and a signature proving that the request comes
from this Mac. Nothing else: no serial number, no machine name, no measurement. The public
half is 65 bytes long, the signature 64. The request carries no cookie and follows no
redirect. The response is an activation certificate, then verified on this Mac, offline: no
further request for the license. If the service does not respond, the same request goes out
again on its own one minute later, then at doubling intervals, six hours at most, for seven
days at most after you choose “Activate This Mac”; after that, nothing more goes out unless
you choose it again.
The code for this request is not published either, for the same reason; the same test checks its headers and its three fields. What the service keeps from it — the license identifier, the fingerprint of the public key and the date, for 400 days, without your IP address — is set out in the privacy policy.
The only two things Quotum writes to an account
Measuring Muse Code creates a key on your Meta account. Meta only publishes Muse Code's quota in its answer to the creation of a key: each measurement therefore creates one, which Quotum does not use, does not read and does not keep — the answer is wiped from memory as soon as the quota is read. Only if Muse Code is tracked, and at most every fifteen minutes: the date of the last request is kept in the preferences, so that relaunching the app does not create one more. Between two requests, the last measurement stays on screen, with its age. No other request goes to Meta, neither to revoke these keys nor to reuse them.
Everything else is read-only. A single other function writes anywhere: spending a reset credit on the Codex quota of a ChatGPT account. It cannot be undone — a reset once spent is lost. These credits are given by OpenAI or earned through referrals, and are valid for thirty days.
It has two paths, and neither fires on its own for a tool you do not track: without consent to measure, no quota is measured, so nothing can conclude that an account has run dry.
- By hand, from an account's drawer. The button states what the spend costs before offering it, and nothing goes out without a second confirmation.
- Without asking, if you have turned it on. That setting is off by default, it only turns on after a warning that the spend may take place at night or while you are away, and every reset it spends is announced to you by a notification.
In both cases, the same conditions apply: a ChatGPT account, a credit left, an exhaustion that the server has observed — never inferred from a percentage, never mistaken for an expired token —, a measurement at most ten minutes old, and a return time still ahead.
06 Check it yourself, without trusting us
Quotum's code has been published, in part and read-only, since October 10, 2026,
in the verification repository
mashgundash/quotum-transparence: the files that read a credential, send a
request, write to an account, keep your consent or launch another publisher's tool, copied
unchanged from the version named in its PROVENANCE file. The interface, the
account matching and the licensing mechanism are not in it, and that repository does not build
on its own. We give these commands with what they return today on the complete code.
The last two run at the root of the verification repository. The first one is about the build
manifest, which is not there: what it establishes can be checked on the installed app, with
otool -L and the contents of Contents/Frameworks. In that
repository, grep -rn 'https\?://' Sources/ returns fewer lines: those of the
unpublished files are missing, namely the addresses your browser opens or that no program
contacts (tables B and C) and, in table A, the two lines of the license service. Its README
lists them.
| Claim | Command | What it returns |
|---|---|---|
| No package downloaded, a single third-party library | grep -c '\.package(' Package.swift | 0 No package is pulled from a remote repository at build time. A single third-party library is embedded: Sparkle, the update framework, stored in binary form in |
| Network session without a cache | grep -n ephemeral Sources/Quotum/Donnees/Outils.swift | 65: … URLSessionConfiguration.ephemeral The neighboring lines also set |
| The addresses, all of them | grep -rn 'https\?://' Sources/ | Each of the lines it returns appears in one of the three tables in section 03, with a comment. We announce no total: it is the list that you compare, not a figure. A line that is missing from them is what you should report to us. |
07 The twenty-five tools it reads
Windows differ from one provider to another, and their length is almost never published. Quotum shows the ones each provider exposes, without converting them into a common unit that does not exist.
| Tool | Published windows | Several accounts |
|---|---|---|
| Claude | 5 h and 7 d, and a 7 d limit specific to one model (Fable) when Anthropic publishes it | yes |
| Codex | 7 d, and 5 h depending on the plan | yes |
| Windsurf | daily and weekly | yes |
| Cursor | monthly cycle | yes |
| Warp | cycle | one line |
| Codebuff | 5-hour block and weekly | one line |
| Augment | billing cycle | one line |
| opencode | depends on the provider | one line |
| Grok | enumerated | one line |
| Grok Bot | 7 d | one line |
| GitHub Copilot | month | one line |
| Kiro | month | one line |
| Cline | 5 h, 7 d and month (ClinePass) | one line |
| Kimi Code | 5 h, 7 d and month | one line |
| Kilo Code | Kilo Pass period | one line |
| Nous Portal | month | one line |
| JetBrains AI | one period, most often the month | one line |
| Factory Droid | 5 h, 7 d and month, in two pools | one line |
| Muse Code | 5 h or 24 h, and 7 d | one line |
| Antigravity | 5 h and 7 d, in two pools | one line |
| Doubao | 5 h, 7 d and month | one line per plan |
| Alibaba Model Studio | 5 h, 7 d and month | one line |
| Amp | 24 h or rolling, and the tier's month | one line |
| Z.ai | 5 h and 7 d, depending on the plan | one line, per pasted key |
| MiniMax | an interval (5 h or 24 h) and 7 d, per model | one line, per pasted key |
Before buying, read the warning as well. None of the twenty-five publishers makes provision for reading back the credentials that a tool has placed on the machine, or for launching its command-line tool. What that involves is written on the pricing page, just above the button.