Skip to content

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.

What a line can say, read off the screenshot opposite, where the app is set to French.
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.

The Quotum panel, with the app set to French: seven accounts from four tools, one line per quota window with its ten-box gauge, and the age of each measurement.
panel, 320 × 646 pt, actual size

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.

One source per tool. None of them is written: Quotum opens them read-only.
Tool Where the credential is read
Claude

Keychain, item Claude Code-credentials, through /usr/bin/security.

Warp

Keychain, items dev.warp.Warp-Stable and dev.warp.Warp-Stable.tui, through /usr/bin/security.

Codex

Every Codex auth.json Quotum knows, the same folder only once: ~/.codex/auth.json, or $CODEX_HOME/auth.json; the CODEX_HOME of each ChatGPT account app (<data folder>/codex/auth.json, or the folder its launcher declares); and the folder a local codex-proxy publishes for each of its accounts (<codexHome>/auth.json), only if it is a real folder, with no link. Each is read, never rewritten. Before each, Quotum reads in the config.toml of the same folder only the keys cli_auth_credentials_store, secret_auth_storage (the one under [features], the only one the CLI applies, a profile changes nothing) and profile, as the CLI does: at keyring, the sign-in is read from the Keychain, item Codex Auth, account cli| followed by 16 characters derived from the folder's path, through /usr/bin/security — an auth.json left over from before is then never read; at auto, the Keychain first, then auth.json only if the item does not exist; at file or without the key, auth.json alone, never querying the Keychain. If secret_auth_storage is enabled, the CLI encrypts its sign-in: Quotum reads neither the item nor auth.json, and the account's line says so; likewise when the config.toml cannot be read with certainty, or holds a profile key, which the CLI rejects. macOS may ask for your permission: a refusal suspends reading that item until the next “Refresh” in the panel, and the account's line says so. A configuration imposed by a device manager (requirements.toml, managed profile) is not read.

Windsurf

~/.local/share/devin/credentials.toml, and the state.vscdb database of Windsurf or Devin in ~/Library/Application Support.

Cursor

Cursor's state.vscdb database in ~/Library/Application Support, key cursorAuth/accessToken.

Codebuff

~/.config/manicode/credentials.json.

Augment

~/.augment/session.json.

opencode

~/.local/share/opencode/auth.json, entry opencode-go.

Grok

~/.grok/auth.json, or the file designated by $GROK_AUTH_PATH and $GROK_HOME. The environment variable GROK_DEPLOYMENT_KEY, if it is set, is used only when the file holds no session.

Grok Bot

The same token as Cursor — the Cursor editor's state.vscdb database, key cursorAuth/accessToken —, read without ever being renewed: Grok Bot's allowance lives on the Cursor account. When the Cursor editor has no session, the Grok Bot app's sign-in: ~/Library/Application Support/Grok Bot/sand-secrets.json, encrypted with a key kept in the Keychain, item Grok Bot Safe Storage, read through /usr/bin/security — macOS may ask for permission. The sign-in is decrypted in memory; the refresh token is never read.

GitHub Copilot

The gh CLI's sign-in to github.com: ~/.config/gh/hosts.yml (or wherever $GH_CONFIG_DIR and $XDG_CONFIG_HOME move it), which names the active account, then that account's token in the Keychain, item gh:github.com, through /usr/bin/security — or in hosts.yml itself, if gh wrote it there in plain text. The gh command is never run, and the token is never renewed.

Kiro

~/.aws/sso/cache/kiro-auth-token.json: the access token, and the organization profile when it is there. The refresh token is never used. For an organization account whose sign-in does not name its profile, and only when Kiro replies that it needs one, Quotum also reads a single key of ~/Library/Application Support/kiro-cli/data.sqlite3: api.codewhisperer.profile (table state), the profile chosen in kiro-cli. The database is opened read-only, never written; the profile goes out in a second and last usage request, to getUsageLimits in the region that profile names, with the same headers, and nothing else is sent.

Cline

~/.cline/data/settings/providers.json, or wherever $CLINE_PROVIDER_SETTINGS_PATH, $CLINE_DATA_DIR and $CLINE_DIR move it: only the session opened by cline auth. The API keys next to it, which can also call a model, are never read.

Kimi Code

~/.kimi-code/credentials/kimi-code.json, or under $KIMI_CODE_HOME: the access token of the kimi CLI and its expiry. The refresh token is never read.

Kilo Code

~/.local/share/kilo/auth.json, or under $XDG_DATA_HOME, entry kilo only. The refresh token is never read.

Nous Portal

~/.hermes/auth.json, then ~/.hermes/shared/nous_auth.json — or under $HERMES_HOME: the access token the Hermes agent stores. The refresh token is never read, and an expired token is not sent.

JetBrains AI

~/Library/Application Support/JetBrains/<IDE>/options/AIAssistantQuotaManager2.xml, and its counterpart under Google/AndroidStudio…: the quota the IDE writes itself. No sign-in is read, and no request goes out: the file says it all.

Factory Droid

~/.factory/auth.v2.loginkeychain, which droid encrypts with a key kept in the Keychain, item Factory CLI, read through /usr/bin/security — or ~/.factory/auth.v2.file and its key auth.v2.key. The sign-in is decrypted in memory; the refresh token is never read.

Muse Code

~/.config/muse/auth.json, or the file designated by $MUSE_AUTH_PATH, then the Keychain, item ai.meta.dev.credentials, through /usr/bin/security: the sign-in opened by muse login. No other key is read.

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.

Each tool's exact command, read-only, and the only paths tried.
Tool What is launched
Antigravity

agy --version, then agy -p /usage --output-format json --print-timeout 8s, from ~/.local/bin/agy, /opt/homebrew/bin/agy or /usr/local/bin/agy. Before version 1.1.11, agy could pass /usage on to the model, and so spend quota to measure it: on an older or unreadable version, nothing else is launched.

Doubao

arkcli usage plan --format json, from ~/.local/bin/arkcli, /opt/homebrew/bin/arkcli or /usr/local/bin/arkcli — only if the real file comes from the @volcengine/ark-cli package.

Alibaba Model Studio

bl usage token-plan --console-region ap-southeast-1 --console-site international --output json, from ~/.local/bin/bl, /opt/homebrew/bin/bl or /usr/local/bin/bl — only if the real file comes from the official bailian-cli installation. The mainland China console (cn-beijing, domestic) is queried only if the first one measured nothing.

Amp

amp usage, from ~/.amp/bin/amp, ~/.local/bin/amp, /opt/homebrew/bin/amp or /usr/local/bin/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.

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:153https://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: DepenseAnthropicEntreprise.swift reuses this host for GET /v1/organizations/spend_limits/effective, restricted to the member followed — never a route that generates a response.

QuotaCodex.swift:86https://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: GET /backend-api/wham/rate-limit-reset-credits, its reserve of resets, then GET /backend-api/wham/rate-limit-reset-credits/history, their history, five pages at most (ReserveCodex.swift), and GET /backend-api/wham/profiles/me, its day-by-day usage, of which Quotum keeps, in memory, only the usage of each day and each week and the date of the data (StatistiquesCodex.swift). The POST …/rate-limit-reset-credits/consume that spends a reset goes to the same host (ReinitialisationCodex.swift:58): section 05.

QuotaCodexJetonPersonnel.swift:28https://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:59https://server.codeium.com

The Windsurf quota. The host may come from the user's file; it is then only accepted under codeium.com, windsurf.com or devin.ai.

QuotaCursor.swift:311https://cursor.com

Cursor's monthly cycle and its on-demand spend.

QuotaWarp.swift:197https://app.warp.dev/graphql/v2

Warp's cycle.

QuotaCodebuff.swift:138https://www.codebuff.com

Codebuff's five-hour block and week.

QuotaOpencode.swift:153https://opencode.ai

opencode usage.

QuotaGrok.swift:251https://cli-chat-proxy.grok.com

Grok credits.

QuotaGrokBot.swift:49https://api2.cursor.sh

Grok Bot’s weekly allowance, on the Cursor account.

QuotaCopilot.swift:270https://api.github.com

GitHub Copilot's monthly allowance of premium requests, through a route GitHub does not document.

QuotaKiro.swift:162amazonaws.com/getUsageLimits

Kiro credits, on q.us-east-1.amazonaws.com or q.eu-central-1.amazonaws.com depending on the account's region — no other is accepted.

QuotaKimi.swift:160https://api.kimi.com

Kimi Code's 5-hour, 7-day and monthly windows, with the token the kimi CLI stores — never renewed by Quotum, and sent without the CLI's identity headers.

QuotaClinePass.swift:195https://api.cline.bot

The windows of the ClinePass subscription, through a route Cline does not document.

QuotaKilo.swift:178https://app.kilo.ai

The Kilo Pass period, through a GET request that can only read.

QuotaNous.swift:73, 172, 291portal.nousresearch.com · https://\(hote)

Nous Portal's monthly allowance. The portal can come from the Hermes file; it is then accepted only over https and under nousresearch.com.

QuotaMuse.swift:264https://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, 74https://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, 77https://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, 367factory.ai/api/billing/limits

Factory (droid) windows, on api.factory.ai or api.eu.factory.ai depending on the account's region — no other is accepted.

DepenseAWS.swift:106, 114https://budgets.amazonaws.com · https://sts.

Only if you have pasted an AWS read-only identity: sts.<region>.amazonaws.com says who is signing, on a closed list of regions, and the root user is refused; budgets.amazonaws.com returns the spend of the budget followed. Requests signed on this Mac by SignatureAWS.swift: the secret key never leaves.

DepenseAzure.swift:83, 84, 87https://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 management.azure.com.

LecteurProxy.swift:17http://127.0.0.1:8787

The status of the Claude proxy, on your own machine. It never leaves the computer.

LecteurProxy.swift:25http://127.0.0.1:8788

The status of the Codex proxy, likewise.

AdressesLicences.swift:9https://licences.quotum.app

The publisher's license service, with two routes: /essai, which EssaiEnLigne.swift appends to it — opening the trial, at first launch —, and /activer, which ActivationEnLigne.swift appends — activating your license, once per Mac, when you ask for it. Nothing else goes there — section 05.

AdressesLicences.swift:5https://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 LICENCES_TEST condition, reserved for development copies; livrer.sh refuses to deliver a copy that contains it.

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 .test domain is reserved and resolves nowhere.

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:

“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.

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 Tiers/ — grep -c binaryTarget Package.swift returns 1 — and credited in THIRD-PARTY-LICENSES.md. Not to be confused with grep -c dependencies, which returns 3: one links the widget to the code it shares with the app, another links the app to Sparkle and to that shared code, the last links the test target to the app and to that code.

Network session without a cache grep -n ephemeral Sources/Quotum/Donnees/Outils.swift

65: … URLSessionConfiguration.ephemeral

The neighboring lines also set urlCache = nil and a policy that ignores any local cache.

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
Claude5 h and 7 d, and a 7 d limit specific to one model (Fable) when Anthropic publishes ityes
Codex7 d, and 5 h depending on the planyes
Windsurfdaily and weeklyyes
Cursormonthly cycleyes
Warpcycleone line
Codebuff5-hour block and weeklyone line
Augmentbilling cycleone line
opencodedepends on the providerone line
Grokenumeratedone line
Grok Bot7 done line
GitHub Copilotmonthone line
Kiromonthone line
Cline5 h, 7 d and month (ClinePass)one line
Kimi Code5 h, 7 d and monthone line
Kilo CodeKilo Pass periodone line
Nous Portalmonthone line
JetBrains AIone period, most often the monthone line
Factory Droid5 h, 7 d and month, in two poolsone line
Muse Code5 h or 24 h, and 7 done line
Antigravity5 h and 7 d, in two poolsone line
Doubao5 h, 7 d and monthone line per plan
Alibaba Model Studio5 h, 7 d and monthone line
Amp24 h or rolling, and the tier's monthone line
Z.ai5 h and 7 d, depending on the planone line, per pasted key
MiniMaxan interval (5 h or 24 h) and 7 d, per modelone 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.

Pricing