tab CLI

tab login

Approve this machine in the console, once.

tab login

Asks whether this machine uses the hosted proxy (proxy.flocktab.com) or a self-hosted one on this machine, then prints a short code and opens the console. Approve the code there and the machine receives its session. Nothing is typed into the terminal except that choice, and no Agent is chosen here.

Login is per machine. Which Agent a project runs as is per folder: see tab use.

On a hosted flock with a saved provider key, login also asks for the flock's unlock, checks that it opens the key, and keeps it in the machine's config (owner-only). The unlock is never stored on FlockTab.

See also: tab use · tab logout · tab status

tab use

Pick or change the Agent this folder runs a harness as.

tab use
tab use claude|codex|grok|kimi

An Agent is one harness on one project. tab claude and tab codex in the same folder are two Agents (that is what the plan counts), each asked for once: the first run of a harness in a folder lists the flock's Agents of that harness (and untied ones it can tie), or makes a new one and asks its kind. The new Agent's default name is that of the folder's Agent under another harness (from .flocktab, or the one the console last saw in this folder or repo), in its project; otherwise the console links it to the project it is named like or, failing that, the one Jev judges it belongs to, and names it after the folder. One dim line says why. The slug adds the harness (dash-f4f-claude). The choice goes into .flocktab at the git root, one entry per harness, and a key for that Agent is minted and kept on this machine. A git worktree of the project (git worktree add, or Claude Code's .claude/worktrees) runs as the main checkout's Agent: .flocktab is not committed, so tab reads the main checkout's.

tab use codex changes the answer for one harness; bare tab use sets the folder's default, which every other command (tab python …) runs as. An older .flocktab with a single Agent applies to every harness until one is set apart.

An Agent that already holds a key on another machine can be used here too, but minting a key here replaces the one there. tab asks before doing it.

See also: tab agent · tab key · tab list

tab claude | codex | grok | kimi | <cmd>

Run an agent on this folder's tab. Everything after the name goes to the agent untouched.

tab claude [args]
tab codex [args]
tab grok [args]
tab kimi [args]
tab <any command> [args]

tab sets the environment that agent reads (its base URL and key, or for Codex a home folder of its own) and starts it. It does not wrap or parse the agent's traffic; the proxy does the gating.

Codex's tab home starts from your own ~/.codex/config.toml: approval policy, sandbox mode, model and effort, MCP servers, profiles and trusted folders all apply under tab codex. Only the tab's keys (where the calls go, the flocktab provider) are layered on top.

On an API-key Agent every call is held, settled and charged to the cap, and a call that would pass the cap is refused before the provider with 402 tab_closed. The key is the one the agent already has: a harness set up with its own vendor key (ANTHROPIC_API_KEY, OPENROUTER_API_KEY, ...) keeps it, and tab only moves where it is sent (the proxy's /t/<key>/<vendor>/v1 route, which forwards the key untouched). A vendor the agent has no key for uses the flock's key, if the flock has one.

On a Subscription Agent the agent keeps its own login (Claude Max, ChatGPT, SuperGrok, Kimi). On an API-key Agent, Grok Build runs through the tab on its own XAI_API_KEY when it has one, else the flock's xAI key (refused when a self-hosted proxy has none), in a Grok home of tab's own with no SuperGrok login in it (your Grok settings are not carried there). On an API-key Agent, Kimi Code runs on Moonshot's API through the tab (kimi-k2.7-code), from a Kimi home of tab's own with no Kimi login in it: on its own MOONSHOT_API_KEY when it has one, else the flock's. The tab key rides in the base URL, the same kill switch and policies apply before the vendor is reached, the call is recorded at list price under the account the vendor names, and nothing is charged to the cap.

OpenCode (tab opencode) is given an inline config that points its openai, anthropic and openrouter providers at the tab and switches every other provider off, since OpenCode would otherwise use any key it finds in the environment and go straight to the vendor. Your own OPENCODE_CONFIG_CONTENT is kept; only the providers are taken over. Pick a model as usual: -m openai/..., anthropic/... or openrouter/.... OpenCode runs metered: it has no plan login FlockTab can pass through.

Pi, Goose, Aider and Copilot CLI are set up the same way, each in the form it reads: Pi loads a FlockTab extension (pi -e) that moves its providers; Goose gets its hosts and runs its openai or anthropic provider; Aider gets its Anthropic and OpenRouter bases; Copilot CLI runs its own-key provider against the tab, never GitHub's models. A model named vendor/model (GOOSE_MODEL, COPILOT_MODEL) goes to OpenRouter. OpenCode, Pi, Goose and Copilot turn on any provider they find a key for, so keys for vendors the tab cannot route (KIMI_API_KEY, GEMINI_API_KEY, ...) are hidden from them. tab says at launch which of the agent's own keys it is using.

With no Anthropic key, Anthropic's API goes to OpenRouter's Messages endpoint instead: with the agent's own OPENROUTER_API_KEY if it has one, else (self-hosted) the flock's OpenRouter key on the box. Claude Code included.

OpenClaw gets a config of tab's own (OPENCLAW_CONFIG_PATH) that includes yours and replaces only its model providers with ones through the tab (flocktab/<openrouter model>, flocktab-openai/..., flocktab-anthropic/...); it needs Node 24.16 or later. Cline gets a --config folder of tab's own with an OpenAI-compatible provider on the tab, on your own Cline model when you have one. A key a harness keeps in its own files (Codex's API-key login in ~/.codex/auth.json, OpenCode's auth.json) counts as its own like one in the environment.

Gemini CLI (tab gemini) and Antigravity (tab agy) speak Google's own API: tab gives them GEMINI_API_KEY and GOOGLE_GEMINI_BASE_URL on the tab (their own Gemini key through the own-key lane), drops what would send them to Vertex or Code Assist around it, and gives Gemini CLI a home of its own whose settings choose the API-key sign-in (yours are copied, not touched). A GEMINI_API_KEY in the .env files Gemini CLI reads (the folder and its parents, ~/.gemini, ~) counts as its own. Antigravity needs modelProvider gemini in its own settings once.

Any other command works too: tab points both the OpenAI and the Anthropic variables at the proxy and runs it. An agent with no consumer plan on a Subscription Agent runs metered on the flock's key, and tab says so.

With logins in the pool for that vendor, a Subscription Agent runs as the login with most room. See tab pool.

--observe (Claude Code 2.1.278 or later and Codex 0.155.1 or later, on macOS and Linux, after tab login) adds hooks that report when a session or a subagent starts and stops, and when one agent sends another a message: identifiers and outcomes only, never the prompt, the message or any tool output. Observability's map draws the links between Agents from these reports, and its Agents reporting line counts the Agents that sent them in the last 24 hours. Codex asks once to trust the hooks; a hook the harness skips leaves links missing, not proof that nothing happened.

See also: tab use · tab pool · tab alias · tab log

tab alias setup | remove | list

Make the plain command (codex) run through the tab (tab codex).

tab alias setup <name>...
tab alias remove <name>...
tab alias list

Writes a small shim named like the agent into ~/.flocktab/bin. With that folder first on your PATH, typing codex runs tab codex. tab removes that folder from the PATH of the agent it starts, so the shim never calls itself.

tab alias setup prints the PATH line to add to your shell if it is not there yet.

tab agent create | kind

Make an Agent, or change its kind or harness.

tab agent create <name> --subscription|--api [--harness claude|codex|grok|kimi] [--cap <dollars>]
tab agent kind <agent> api|subscription
tab agent harness <agent> claude|codex|grok|kimi|any

An Agent is one harness on one project, with one tab. Two things are declared: its kind (api: the cap is the meter, paid by the agent's own vendor key or else the flock's; subscription: your own plan logins, nothing charged) and its harness (claude, codex, grok, kimi, or any for scripts). The proxies enforce the harness: a Claude Agent's key cannot pass a Codex login through (403 wrong_harness), so Claude and Codex on one folder are two Agents and count as two.

A subscription Agent's cap is never touched, so tab list shows none; its tab is the kill switch.

Changing the kind applies to the next launch. tab claude reads it fresh every time. It also applies at once to sessions already running: a subscription session is refused with 403 not_subscription on its next call once its Agent is api. To try an API-key Agent in a folder that has sessions running, make a new one and tab use it there instead, then tab use the original again.

See also: tab use · tab cap · tab accounts

tab list

Every Agent: kind, state, spent of cap, window, project.

tab list

One row per Agent in the flock. The same list tab use chooses from.

See also: tab status · tab live

tab close | open [agent]

The kill switch. Close stops the next call; open lets calls through again.

tab close [agent]
tab open [agent]

Closing a tab takes effect on the next call: it is refused before the provider or vendor with 402 tab_closed. Calls already in flight finish. This works the same on API-key and Subscription Agents.

A tab that closed itself by reaching its cap reopens by itself when its window rolls over (unless its reopen rule says manual or never), or now with tab open.

See also: tab cap · tab policy

tab cap

Set the hard cap, its window, and what happens at the cap.

tab cap [agent] <dollars>
tab cap [agent] --on-cap close|pause --reopen window|manual|never

The cap is a hard dollar limit on one Agent for one window. Before every call the proxy holds the call's worst case against it (its input, counted a quarter high, plus its whole output limit), so a call cannot start unless it fits. What is charged is the vendor's own count: if that comes in above the estimate (a long system prompt, tool schemas, images), the call is settled at it and the tab closes, and nothing runs after it.

A call whose worst case does not fit what is left (a harness that asks for 64,000 output tokens on a $1 tab) is fitted instead: its output limit is lowered to what the remaining budget pays for, and the provider is asked for that; the reply says so in x-flocktab-fitted-max-tokens, and the decision log reads fitted to N of M output tokens. Below 2,048 output tokens (8,192 for a call with a reasoning effort or a thinking budget, which spends output before it answers) the call is refused instead (this call could cost up to $X; $Y left on the tab), and the tab stays open. The tab closes when its spend reaches the cap.

The window is how often the spent amount starts again: hour, day, week or month, from the start of each in the flock's time zone (Settings); run and lifetime never reset. Changing the window starts the new one from now.

--on-cap close (the default) closes the tab at the cap, the same as tab close. --on-cap pause refuses calls over the cap but leaves the tab open: the next window, or a higher cap, carries on by itself.

--reopen says when a tab its cap closed opens again: window (at the next window), manual (tab open, the default) or never (only after you change this). A tab you closed yourself is never reopened for you.

See also: tab close · tab policy · tab spend

tab policy

Show or set the rules checked before every call.

tab policy [agent]
tab policy [agent] --velocity N|none --models a,b|none --allow tool,tool|none
tab policy [agent] --guard off|watch|ask|deny --loops off|watch|pause
tab policy --all --guard off|watch|ask|deny --guard-level ... --loops ...
tab policy --default-guard off|watch|ask|deny
tab policy [agent] --guard-level relaxed|balanced|strict --reach on|off --flag <pattern>|none --trust <pattern>|none --forget <pattern>

Checked in this order, first refusal wins: tab state, cap, velocity (calls per minute, 429), model allowlist (403 model_blocked), irreversible tools (403 risk_blocked), per-tool caps (402 tool_cap).

A tool FlockTab does not know is treated as a write, not a read. Irreversible tools (payments, sending email, deletes, production deploys) are denied unless named in --allow, and even then only while at least $25.00 of the cap remains.

--guard turns on Agent Guard and --loops the loop watch for tab claude, tab codex, tab gemini, tab agy, tab opencode, tab goose, tab cline, tab grok, tab kimi and tab pi, from the next launch. Agent Guard judges each tool call before the harness runs it: known irreversible commands (a force-push, DROP TABLE, a production deploy, a payment) by rule, the rest by TypeSafe's judgment model. watch records, ask has you confirm in the terminal (Codex, OpenCode, Goose, Cline and Kimi Code have no way to ask from a hook, and nobody can answer a headless run such as -p: the agent is told to ask you), deny refuses. In Cline a refused call is not held open (Cline gives a plugin three seconds): it is refused at once and stays in the review queue, so you can allow it there or with tab guard allow and the agent retries. Goose on Windows is not covered yet: its commands run unchecked, and tab says so at launch. Read-only tools and agents messaging each other (SendMessage, the task tools) are never judged. A plainly read-only shell command (readers such as ls, cat, grep, find, sed -n …p, sort, tree, diff, git status or git log, piped into each other or after a cd into another folder, with nothing redirected and none of their writing options; git after a cd is judged, since another repo's config can run code) and a call already allowed earlier in the same session go ahead at once and are recorded afterwards. An agent rewriting Claude's or Codex's own permission settings always asks. If flocktab.com cannot answer in time, the rules decide alone. Your answers in Claude Code's own prompt teach it: a no flags that exact command on the Agent at once (at most 40 learned rules, kept apart from your own patterns and never replacing them); a yes trusts nothing until you confirm it on the console's Agent Guard page.

--guard-level sets how sensitive the guard is (balanced unless set). relaxed stops only what surely cannot be undone, by rule, has TypeSafe's model flag a call only when it is 80% sure, and never checks reach. balanced adds calls the model is 50% sure cannot be undone, and reach. strict also stops any git push, any delete, a web request that sends data, a database or cloud write, and an MCP tool that creates, changes or sends, and has the model flag from 30%.

With the guard on, reach (on unless --reach off) also stops calls outside the project by rule: ssh, scp or rsync to another machine, sudo, kubectl exec, a database client pointed at another host, reading private keys or credentials files, and Claude Code turning its own sandbox off (dangerouslyDisableSandbox). A plainly read-only command, such as reading a file in another folder, may leave the sandbox without asking; reading keys or credentials (however the path is written, in any case, globbed, after a cd into their folder, or by a recursive grep, rg or diff over any folder they sit under, such as ~/.config or your home folder) or anything under /etc, /var or /private other than listing it still asks. Codex does not tell hooks when it asks to leave its sandbox, so there the guard judges the command itself. When only the model thinks a call reaches past the folder (a grep or a cd elsewhere), it asks only if the call may also be hard to undo or carries some risk.

Tune it with your own patterns; case and repeated spaces do not matter. --flag adds one the guard always stops: it matches when the command, or the tool's name, starts with it, and * matches anything ("*prod*", "mcp__linear__delete*"). --trust adds one it always lets through, before every rule, and trusts exactly what it names: without * only that command; with *, anything it matches except text that chains or redirects (; && || | ` $( > <), so "npm test*" never trusts "npm test; rm -rf ~" ("ssh staging-bastion*"): keep those narrow. --forget removes a pattern; none clears a list. Up to 40 of each. The same settings are in the console, on Policies and on the Agent's page.

The loop watch looks at the last ten tool calls every three calls and records an agent that keeps repeating itself, or that has spent half an hour or more only waking up to re-run the same check; pause also closes its tab, the same as tab close, once it has been stuck that many checks in a row (two unless --pause-after says otherwise). Each tool call (the command and its arguments, including the text of a file write) goes to TypeSafe's judgment model with keys, tokens and passwords removed, and only a 200-character summary is kept; tool output never leaves the machine. Codex asks once to review FlockTab's hooks: choose Trust all and continue. codex exec never asks: until that one-time answer it skips the hook and its commands run unchecked, and tab says so.

See also: tab cap · tab ledger · tab guard

tab guard [allow|deny <id>]

Review what Agent Guard held or blocked: keep it blocked, or propose an allow to confirm in the console.

tab guard [--agent slug] [--filter pending|blocked|allowed|all]
tab guard allow <id> [--always [--pattern <p>]]
tab guard deny <id>

When Agent Guard refuses a call (deny, or ask under Codex), the call waits for a person, 45 seconds unless the Agent says otherwise. Allow it in that time and it runs there and then; otherwise it is refused and stays in the list.

deny keeps it blocked, there and then. allow only proposes: it prints a link and a code, and the call is allowed when you confirm it in the console, signed in. The agent can reach the terminal it runs in, and so tab's login, but not your browser session. Confirmed, the exact call runs if it is still waiting, else its next try within 10 minutes passes; --always also trusts one narrow rule on that Agent, the exact command by default (never a bare * or a shell by name). Other unanswered requests for that exact command on the same Agent are answered together, including expired requests; earlier answers are kept. Every decision is final and recorded with who made it.

tab guard allow and deny also refuse inside an agent tab launched, under a harness process (claude, codex and the rest), and without a terminal. The full command is read from this machine, where the agent ran, so what you propose is what you saw; the console's Agent Guard page can also decide, but not a call it could not show in full.

See also: tab policy · tab top

tab rename

Rename an Agent. Its slug, and so its console URL and .flocktab files, stay.

tab rename <agent> <name>

The display name changes everywhere. The slug is permanent so folders and links keep working.

tab key rotate [agent]

Mint a new key for an Agent, kept on this machine. The old one stops working.

tab key rotate [agent]

Keys look like ft_live_... and are stored hashed; FlockTab cannot show one again. The old key is refused (401 key_revoked) from the next call, on every machine that still holds it.

See also: tab use

tab project | projects

Group Agents under a project for chargeback (Team plan and up).

tab projects
tab projects add <name>
tab project [agent] <project>|none [--create] [--repo owner/name]

A project is a label on FlockTab's own meter: what these Agents spent, together. --repo links a GitHub repository so outside spend (Actions, storage) can be attributed to the same project.

With one word, tab project puts this folder's Agent in that project. With two, the first is the Agent (its name or slug, as tab list shows) and the rest is the project. Quote a project name with spaces. tab project help, like tab <command> help for every command, prints this page.

See also: tab spend · tab outside

tab archive

Close an Agent for good and take it off the bill. Its history stays.

tab archive [agent]

The tab closes for good, the Agent leaves the lists and stops counting towards the plan's Agents. Its ledger rows stay.

Its keys stop working everywhere (the proxies answer key_revoked). A folder still bound to it asks for an Agent again on the next launch.

tab accounts

Every plan login your Subscription Agents were seen on, and how used it is.

tab accounts

Accounts are discovered, never typed in: the vendor names the login on every reply, and FlockTab files the call under it. Each row shows the plan, the seat price taken from the plan tier, what the last 30 days would have cost at list price, the number of calls, and the usage the vendor last reported per window. A ChatGPT login that has rate-limit resets banked says how many (2 resets banked).

The console shows the same under Setup, Subscriptions, where a label or a seat price of your own is set.

See also: tab pool · tab agent

tab pool [add | login | at | swap]

Several logins of one vendor on this machine; the agent runs as the one with most room.

tab pool
tab pool add claude|codex|grok|kimi <name> [--email <address>] [--dir <folder>]
tab pool login [claude|codex|grok|kimi] <name>
tab pool remove claude|codex|grok|kimi <name>
tab pool at [claude|codex|grok|kimi] [7d] <percent>|default
tab pool rebalance <points>|off
tab pool swap auto|launch

pool login <name> signs a login in again, in its own folder, with the vendor's own browser sign-in: for one whose sign-in expired (Claude says Not logged in). Name the vendor first when the same name is in more than one pool; in a terminal tab asks which. Windows already running on that login pick it up on their next call. On macOS tab reads when Claude Code last refreshed each login (the keychain entry's date, never the login): one not refreshed for three days is marked in tab pool as last refreshed N days ago, and the pool does not move onto it while another login has room.

A pool member is a folder the agent signs in to itself (CLAUDE_CONFIG_DIR, CODEX_HOME, GROK_HOME, KIMI_CODE_HOME). tab never reads, copies or forwards a login, and neither proxy holds one: tab only chooses which folder a launch uses. pool add opens the vendor's own browser sign-in and finishes by itself. The login then shows in the console under Subscriptions at once, before its first call: tab tells the console the account's id, email and plan tier as the agent's own files state them, never the login itself.

Usage is what the vendor last reported for that account. The short window (Claude's 5 hours, Codex's primary) decides: at or over the threshold, the login gives way. The long window (the week) is ignored until it reaches its guard, 95% unless set, and then the login gives way whatever the short window says. Between logins within five points of each other, the one with more of its week left goes first. A login never seen through FlockTab counts as unused.

At launch tab takes the login with most room. While running (swap auto) it looks once a minute; when the login in use is over a limit and another is not, it waits for a quiet moment (this session has no call in flight and began none in the last 20 seconds; other sessions do not hold it back), stops the agent and starts it again as the other login in the same conversation, reopened by its own id, so two sessions in one folder each come back as themselves (Claude Code: the conversation the window is in at that moment, as its status line last said, so after a /clear or /resume too; one where nothing was said yet starts again under the same id. Codex: when tab can tell which conversation was this run's; otherwise the folder's most recent, and tab says so). Windows move onto one login one at a time, about 90 seconds apart, so they do not all refresh its sign-in at once. When the harness ends at once on the new login, tab goes back to the one it came from, in the same conversation, and does not try that login again in this run. The vendor's prompt cache does not carry over, and anything typed but not sent is lost. Rebalance (30 points unless set) also moves off a login that is fine when another's week is at least that many points emptier and its short window has the same margin to spare, at launch and while running; the margin keeps two logins from trading places. A running agent reads the pool's settings at every check, so changing them moves it within a minute. When every login is over, nothing moves, and at launch a login with a banked rate-limit reset (ChatGPT) runs first, else the least used.

Members share your own conversations (~/.claude, ~/.codex, ~/.grok, ~/.kimi-code), so a conversation continues under another login and can be resumed with or without the pool. The pool lives in ~/.flocktab/pool.json on this machine only.

See also: tab accounts · tab claude

tab status

Which flock, which Agent this folder runs as, its kind, and whether the proxy answers.

tab status

The first thing to run when something is off. Exit code 0 only when the machine is logged in, the folder has an Agent with a key here, and the proxy is healthy.

See also: tab login · tab use · tab up · tab whoami

tab whoami

Which Agent this folder runs each harness as, and whether this machine's key for it works.

tab whoami

Only reads: it never asks, and never creates or keys an Agent. A folder with no Agent says so; a key the proxy refuses (key_revoked) is shown with the command that fixes it.

A launch whose key is refused stops the same way instead of starting the harness, and tab never creates an Agent from closed input: with nobody to answer (an agent's shell tool, a closed pipe) the picker stops and says so.

See also: tab status · tab key · tab use

tab top [--every <seconds>] [--once]

The flock live in a scrolling screen: Agents, the leaderboard, subscriptions and their windows, the pool, outside spend, the ledger.

tab top
tab top --every 5
tab top --once

An always-on dashboard in the terminal, redrawn every 2 seconds (--every sets it). When npm has a newer tab (asked every half hour), a line above everything says so: q, then tab update. At the top: the flock, its plan, Agents used of the plan's limit, whether the proxy answers. Then who is working right now, calls per minute, calls blocked and spend in the last 5 minutes (5m), with their trend; every Agent with its harness, project, spent of cap, calls per minute, calls blocked in the last 5 minutes and its last decision (an Agent run from two terminals at once, two `tab claude` launches in one folder, reads ×2, and the working count adds the sessions); every subscription login with each of its windows (for Claude, the general 5h and 7d windows and Fable 7d, Fable's own week) and how long until each resets, its calls in the last 30 days (30d), the rate-limit resets a ChatGPT login has banked, and the pool's next pick marked, with every Agent on that login (an Agent shows only under its own vendor's login: a Claude Agent under Claude, a Codex Agent under ChatGPT, even when both logins share an email); outside spend by project over the last 30 days with the unattributed share; and the ledger's latest decisions as they happen. Under the Agents, Branches today, in your flock's time zone (Settings), not this machine's: each branch a tab session was on (with its pull request number in front when the GitHub CLI, gh, is signed in on your machine), with what went on the tab, subscription use at list price and the share of each login's week it took (≈), the minutes with calls and the sessions (the Projects page has the last 30 days). Then the Leaderboard for your flock's day (midnight in the flock's timezone), with the week's biggest token user beside its title: Token hogs (most tokens in and out per Agent), Speed demons (the fastest models by median output tokens per second, once a model has 5 timed calls), Peak pace (each Agent's busiest minute and the flock's, with when), Big spender (the single priciest call at list price) and Cache champ (the biggest share of input read from cache, once an Agent has 5 calls). When one of them is broken while you watch (a new first place, a busier minute, a pricier call), a line reads 🏆 new record for 30 seconds. The boards are read every 30 seconds. Calls settled by a proxy older than the boards have no timing or cache count and are left out of those two. Tally, FlockTab's sheepdog, sits beside the header in a colour terminal at least 24 rows tall: he trots while Agents work, barks when calls are blocked or the proxy is down, and wags when all is quiet. On a dark background he wears a lighter coat so he does not vanish: tab top asks the terminal for its background colour (or reads COLORFGBG), and t switches his coat by hand and keeps the choice.

The header (Tally and the totals) stays put and everything under it scrolls: every Agent, every login, every outside project and the whole ledger tape are there, never cut to fit. ↑/↓ or j/k move a line, PgUp/PgDn or space/b a page, g or Home the top, G or End the bottom, and the mouse wheel three lines. A dim footer says which lines you are looking at when there is more than the screen holds, and a refresh keeps your place.

q, Escape or Ctrl-C leaves and the terminal is as it was, mouse included; r redraws at once. --once prints everything once and returns, for a pipe or a quick look. A panel the console cannot answer on a tick is a line above the footer, and the last good read stays on screen. Everything comes from the console the other commands read, so nothing here disagrees with tab list, tab pool, tab accounts or the Console.

See also: tab list · tab pool · tab accounts · tab live · tab status

tab statusline [harness]

One line for a harness's status bar: the Agent and its tab, or the plan's windows.

tab statusline [claude|codex|grok|kimi]
tab statusline install grok|kimi

Prints what this folder runs the harness as, then either spent of cap for an API-key Agent or, for a subscription, the login in use and each window's usage as the vendor last reported it (5h 36% · 7d 29%). On a pooled run it names the pool login the run is on and how many logins the pool has (pool me@x.com (4)). Read from the console at most once a minute, so a status bar that refreshes every few seconds costs nothing.

Your own status line stays. tab runs it first (Claude Code's from settings.local.json or settings.json, Grok's and Kimi's from their config, with the same stdin the harness gives) and adds its own line after it, every line of yours kept. Claude Code shows the pair on every tab claude, passed on the command line so no file of yours is touched (your own --settings wins). Grok Build and Kimi Code read a status line only from their config; a pool member gets it (that home is tab's), and tab statusline install grok|kimi puts it in your own config after asking: the file is backed up next to it first and a command already there is set aside and keeps running first. Codex takes no command and already shows its own limits.

See also: tab status · tab accounts

tab log [-f] | log --proxy

Everything that went through the tab, one line per call.

tab log [-f] [--all] [--lines N]
tab log --proxy [-f]

tab log reads the flock's ledger and shows the calls of the Agents keyed on this machine: time, Agent, what was called, tokens in and out, the amount, and the outcome (settled, subscription, refunded, blocked and why). It works the same on hosted and self-hosted.

tab log --proxy (also tab logs) is the self-hosted proxy's own log on this machine: one line per call with the vendor, model, status, cached tokens and milliseconds. Neither log ever contains a key, a login, a prompt, an email or an IP address.

See also: tab ledger · tab live

tab ledger

One row per call, with the hold and what it settled at.

tab ledger [agent]

SETTLED $0.08 of $0.14 held means $0.14 was held before the call and $0.08 was the real cost; the rest went back. REFUNDED means the provider failed and nothing was charged. SUBSCRIPTION is a call on your own plan, priced at list and not charged. BLOCKED names the rule that refused it.

See also: tab log · tab spend

tab spend

What was spent through the tab, and outside it, grouped: by Agent, project, day, or model and effort.

tab spend [agent|project|day|model]

Meter spend is what went through FlockTab. Outside spend is what the connected billing sources report (Team plan and up), so the two can be told apart.

tab spend project is the last 30 days for every figure, as the Projects page: each project's meter (committed calls), its outside spend and the unattributed outside; --since does not change it.

tab spend model lists each model with the reasoning effort the requests asked for (OpenAI's reasoning effort, Anthropic's effort or thinking budget), how many calls, what they cost and how they were paid: charged to a tab, or priced at list on a plan. The console shows the same under Spend, Models.

See also: tab outside · tab ledger

tab outside

The outside-spend connections and their totals per project.

tab outside

Connections are made in the console (Spend, Outside spend): provider admin APIs and cloud billing. They answer whether a dollar went through a tab or around it.

The console pulls every connected source on its own, once an hour; the last sync shows per connection.

See also: tab spend · tab project

tab live

Who is active right now.

tab live

Each Agent's pulse (active, quiet, idle, stopped), calls per minute and last decision. Active means a call was admitted in the last minute. Quiet means calls in the last five minutes, but not the last minute.

tab web

Open the Agent's page in the console.

tab web [agent]

Opens this folder's Agent when none is named.

tab up | down

Start or stop the self-hosted proxy on this machine.

tab up
tab down

The self-hosted proxy is one binary (flocktab-proxy). Your provider keys live in ~/.flocktab/proxy.env on this machine, owner-only, and never reach FlockTab. The proxy asks flocktab.com to hold, settle or refund each call with the Agent's own key, so caps, policies, the kill switch and the ledger work exactly as on hosted.

tab up asks for provider keys the first time (typed without echo), starts the proxy on 127.0.0.1:8787 and waits until it answers. tab claude on a self-hosted machine starts it by itself when it is down.

tab down stops the proxy that tab started. Anything running through it is cut, so stop your agents first.

See also: tab log · tab update · tab status

tab update

Install the newest tab from npm, and with it the newest proxy.

tab update
tab update --quiet

Restarts a self-hosted proxy that was running, so it runs the new version. Stop your agents first on a self-hosted machine. A proxy started with provider keys in its environment (not saved in proxy.env) is left running instead, with the keys a restart would drop named: restart it yourself with them set.

In a colour terminal, Tally asks npm for the newest version first, trots beside the install (in the coat tab top gives him: the one t chose, else lighter on a dark background), and ends with the new versions and two or three lines on what is new. Already on the newest, nothing is installed. If npm does not answer, nothing changes and tab exits non-zero.

--quiet (or -q), a pipe or NO_COLOR prints plain lines and always reinstalls from npm.

See also: tab version

tab version

The versions of tab and of the proxy it carries.

tab version

A proxy that is older than tab can miss features; tab says so when it notices.

tab logout

Forget this machine's session and Agent keys.

tab logout

Removes ~/.flocktab/config.json. The pool, the proxy's provider keys and each folder's .flocktab are left alone. The Agents and their history are untouched on FlockTab.

See also: tab login