---
title: Accounts and usage
description: Use several accounts per provider, choose how Lookout routes between them, and see what each plan has left.
canonical_url: https://lookout.arcadia.is/docs/usage
type: guide
section: Use Lookout
last_updated: 2026-11-16
related:
  - https://lookout.arcadia.is/docs/models
  - https://lookout.arcadia.is/docs/account
---

> Every page of these docs: https://lookout.arcadia.is/llms.txt

# Accounts and usage

Use several accounts per provider, choose how Lookout routes between them, and see what each plan has left.

Lookout reads each plan's limits from its provider and shows what is left. With more than one account on a provider,
you choose how requests spread across them. **Settings › Usage** counts tokens and turns; it shows no prices.

## Add another account

1. Open **Settings › Providers** and click the provider's row to open its page.
2. Beside **Accounts**, click **Add account**.
3. Sign in with the other account, the same way as the first ([Connect a provider](https://lookout.arcadia.is/docs/models#connect)).

A provider's sign-in page signs in whoever your browser is already signed in as, so Add account doesn't open it by
itself. Click **Open sign-in** if your browser is signed in to the account to add, or **Copy link for a private
window** and open it in a private window (or another browser profile) on the same Mac, then sign in there, or finish it
[from another device](https://lookout.arcadia.is/docs/models#another-device).

Most providers take up to fifteen accounts; Cognition's Devin takes one ([Providers](https://lookout.arcadia.is/docs/models#providers)). The menu at
the end of an account's row has **Rename**, **Sign out**, **Sign in again** once its sign-in expires (or ends within
three days), and, with two or
more accounts under One account or Failover, **Use for requests**, and under Failover or Balance **In the shared pool**
([below](https://lookout.arcadia.is/docs/usage#exclude)). **Rename** gives the account a name of your own,
such as **Work**: the row, the chat's account and the chat's notices use it, with the account's address beside it in
the row. Save an empty name to go back to the address.

**Sign in again** renews that account, so pick the same account on the provider's page. If you sign in as another
one, Lookout saves nothing and names the account to sign in as; add the other one with **Add account**.

An expired account your Lookout account holds is listed even on a device that never had it, with **Sign in again**
and **Sign out** and no **Rename**: there, **Sign in again** takes whichever account you sign in as, and it replaces
the expired one on all your devices.

## Choose how requests use your accounts

With two or more accounts, the provider's page shows **Use** under **Plan use**:

| Option | Requests go to |
|---|---|
| **One account** | The account marked **In use**. While it can't take them (its limit reached, its sign-in refused), the account whose allowance resets soonest among those with room does. A chat already working there stays while its cache is warm and that account has room, and returns when its cache goes cold. **Use for requests** in another account's menu moves them there at once. |
| **Failover** | The account marked **Primary** until it has the percent you set in **Switch at** left (5 to start), then the account whose allowance resets soonest. New chats return to the Primary once it has room again; a chat already working on another account stays there while it has room. **Use for requests** makes an account the Primary. |
| **Balance** | The account whose allowance resets soonest, among those with room (a new chat skips one that is nearly spent while another isn't), so less of it resets unused. A chat whose prompt cache is warm stays on its account until that account's limit is reached, since a move reads the whole chat again; **Switch at** steers only new chats and chats idle past the cache's lifetime. A chat that has to move goes back to an account that still holds its cache from earlier in the hour, when Balance would consider that account too and it is used at most 2 points more than the one Balance would pick. The exception is the first account you signed in with, the one kept for your own use: while it is in the pool, a chat on it moves at **Switch at** too. |

Under Failover and Balance, a request that fails on one account before anything comes back moves to another (a short
pause the provider asks for is waited out on the same account, a server error is retried there twice before the chat
moves, and a dropped connection never moves it, since a move reads its whole prompt again). A summary of a long chat
runs on the account the chat is on while that account can take it, even when it is nearly spent, since the summary
reads the chat from that account's cache; the chat moves after it, with the shorter context. Under Failover, **Answering now** marks
the account requests go to while it isn't the Primary; Balance marks none, since its pick changes request by request.
Under One account, a request the account in use can't
take goes to the account with room the same way, and **Answering now** marks that account; nothing else changes, and
a chat whose cache is warm there stays until it goes cold, when its turns go back to the account in use. A limit reached partway through an answer stops that turn;
the next one moves. With one account left, the provider goes back to One account unless you chose the option yourself.
With two or more accounts and no option chosen, a provider uses Balance. The option, **Switch at** and which accounts
are excluded follow your Lookout account: every machine signed in to it routes the same way.

### Exclude an account from the pool

Switching off **In the shared pool** in an account's menu, under Failover or Balance, keeps automatic switching off that
account: neither sends a request there on its own, and a chat working there moves to another account at its next
request. The row then says whom it serves: **Only** and the agents that have it, each a way to its profile, or **Not in
use** with **Choose agents**, the agents by section (a section's name checks all of its agents). Switching it on brings
it back. A chat you picked that account for, and the Primary, still use it (the Primary's menu offers no switch). Under
One account the mark doesn't apply: when the selected account runs out, requests go to the account with room that
resets soonest, an excluded one too, unless an agent has it (the option's hint says so).

An agent's profile has **Accounts** under **Models**: **Shared pool**, or for each provider with two or more accounts the
ones it draws from, in the pool or not, with **Balance** or **Failover** between two or more (the first listed is the
Primary). Its chats, its routines' chats, the chats it starts and their subagents then use those accounts alone, and
never the pool on that provider, nor paid extra usage: when they are spent it waits for the first of them to reset, or
goes on with a fallback model. A chat's own account still comes first, and its account chip lists the agent's accounts.
With only excluded or spent accounts left, a chat waits for the
first account in the pool to reset, as when every account is spent, and every surface that counts the pool says so:
an excluded account never counts toward **1 of 4 open**, the plan's word beside the ring or **Limit reached**, and its room
doesn't end the wait. Its segment and column come last, faint, and in **Settings › Usage** its line sits under **Not in
the pool**. When the pool is spent and an excluded account has room, the row says so, such as **Limit reached; Personal
is out of the pool**, and the usage card says it under its head. When an account in the pool has room again, one
waiting chat goes first, and the rest once it got an answer.

Under Failover and Balance, switching the option or the Primary changes where new chats go; a chat whose prompt cache is still warm (it
worked within the provider's cache lifetime, an hour on Claude and 5 minutes for a Claude subagent) stays on its account while that account can take it (under Failover, until **Switch at**), so it
doesn't re-read the whole chat on another one. Restarting Lookout, or an update, keeps that too, and so do
`lookout exec` and `lookout resume` from one run to the next.

## Choose the account a chat uses

In the model menu, a provider with two or more accounts has a chip at the end of its line, over its models: **Auto**
(the provider's **Use** choice decides), or the account the chat chose, by the part of its address before the @ when
that tells it apart. Open it to pick another. Each account says what it has left on its tightest window, the one with
most room first; accounts at their limit say **Limit reached** and come last, and the whole address is in the row's
tooltip.

Once a chat chose an account, the line under the message box names it too, and opens its own menu, where
accounts at their limit say when they are back and **Manage accounts** opens the provider in Settings. On **Auto** it
shows nothing there.

- A chosen account takes the chat's next turn and its subagents' requests to that provider ([a subagent on another model](https://lookout.arcadia.is/docs/subagents#model) uses that model's provider). A turn already running stays on its account.
- The chat goes to another account while its own is spent or refused, and comes back once it has room again.
- **Auto** gives the chat back to the provider's **Use** choice.

The [plan's part](https://lookout.arcadia.is/docs/usage#usage-mark) of the ring's card lights the chat's account: the one you chose while
it can take the chat's requests, else the one the chat's prompt cache is warm on, else, under One account or Failover,
the one requests go to. Under Balance a new chat lights none, nor does one idle past its cache's lifetime or switched to
another model since: where its next request goes isn't known until it is sent. The light moves only once the chat has
stayed on its new account for a moment, so a quick back and forth never shows.

When a turn moves to another account partway, the chat says **Switched to** that account where it moved, and the
turn's footer names both, such as **via ada@example.com, then bo@example.com**.

## The plan under the message box

The plan has no mark of its own: it is the **Plan** part of the [context ring](https://lookout.arcadia.is/docs/context#meter)'s card, at the end of
the line under the message box. The ring says nothing of it while the chat can keep working on its model. Beside the
ring, **Plan low** in amber says every open account is at 15% or less, **Back in 1h 15m** in red that no account can
take the chat's next request (**Limit reached** when no reset is known), and **Sign-in expired** that every account
needs a new sign-in.

Click the ring for the plan's windows, under **Plan**. With several accounts the card is one grid: a row per window (**5-hour**, **Weekly**,
and the chat's model's own window when that binds first), a column per account, **1 of 4 open** at the top, and at a
row's end when the next account that window closed comes back. When the pool runs out before the window that binds it
resets, the [run-out line](https://lookout.arcadia.is/docs/usage#usage-page) sits under the head. The chat's account is the lit column
([which one](https://lookout.arcadia.is/docs/usage#chat-account)). A window that can't be used before its account is back is drawn faint.
Point at a column to read that account's address, plan and values; click it to open the account in **Settings ›
Usage**.

## Read a plan's meters

Open a provider's page to see each account's plan windows (**5-hour**, **Daily**, **Weekly** or **Monthly**, as the
provider reports them), each with what is left and when it resets. A plan that also limits one model on its own,
such as a Claude plan's weekly limit for Fable, shows that window after the plan's, named for the model (**Fable
weekly**); it limits only that model, and under Failover or Balance only that model's requests move to another account.
The provider's row in the list shows the window with the least left, such as **Weekly 52% left**; with several accounts it says how
many can take a request and when the next one comes back instead, such as **1 of 4 open** and **1 back in 1h 15m**, as
**Settings › Usage** does. Closed, the row shows a red alert mark once every account's plan is spent. A plan read more
than a minute ago is read again as the page opens, and its row updates by itself when the answer comes. The refresh
button beside the **Providers** title reads every plan again.

| You see | It means |
|---|---|
| **52% left** | What is left of this window. At 15% or less it turns to a warning color. |
| **<1% left** | Almost spent. |
| **Limit reached** | Spent until the reset shown under it. |
| A sentence in red, such as **This Claude account is on hold** | The provider stopped this account for a reason of its own, with no reset to wait for. The sentence says what to do. |
| **Not started** | The window hasn't started yet, so all of it is left. |
| **Reset, updating** | The window reset since the last reading; the next reading replaces it. |
| **Rate limited for a moment** | The provider asked for a pause. The plan isn't spent. |
| **Usage appears after your next request.** | This provider reports usage only alongside its replies. |
| **No active plan** | The provider says this account has no plan any more: it was canceled, it expired, or the account never had one. Hover for the provider's reason. Its models don't run until you renew the plan (**Renew plan** opens the provider's page when Lookout knows it) or remove the account. |
| **Refused by** the provider, such as **Refused by Anthropic** | Another device reports that the provider refused this account (HTTP 403): its plan ended or its access is off. On this device such an account reads as needing a new sign-in, with the reason beside **Sign in again**; **Check plan** opens the provider's plan page when Lookout knows it. |
| What the provider answered, such as **Z.ai answered 500**, or **Usage last read** | The last reading failed or brought nothing new, so the numbers shown are older. Hover for the provider's whole answer. |
| An amount, such as **USD 4.73** | A prepaid balance, shown in place of windows. |
| **Extra usage on** | The plan's paid extra usage is turned on, with what it used when the provider says. **In use**: replies are drawing on it now ([when a plan runs out](https://lookout.arcadia.is/docs/usage#plan-runs-out)). |
| **Budget left USD 99.58** | What an API key billed per token still has of the budget you set, by Lookout's own count on this device. It is not the provider's remaining credit: a normal key cannot read that. At the budget the account stops taking requests until you raise it. A key the provider has refused for credit shows that sentence instead, even when budget left is still positive. |

A badge beside the account, such as **ChatGPT Plus** or **Claude Max**, is the plan's name when the provider reports
it. On Anthropic's page an API key's badge says **API key**.

## When a plan runs out

- The model menu says so on that provider's models: each row ends with when it is back, and its tooltip says
  **Weekly limit used up, resets in 3d 2h**; the provider's mark on the rail carries a red light. They stay
  pickable: the window resets, and another account may have room.
- A model whose own limit is used up while the plan has room, such as **Fable weekly limit used up, resets in 3d 1h**,
  says so on that model alone: in the model menu, on its row under **Models** on the provider's page, and as a
  row of its own in the message box's usage card; **Continue on** doesn't offer it. The provider's other models run
  as usual. With several accounts it says so only once the limit is used up on all of them.
- Requests move to an account with room left, under any **Use** choice. Under One account a chat warm on the other
  account stays there until its cache goes cold, then its turns go back to the account in use.
- Each Claude account is its own sign-in, whatever Claude Code is signed in to: with several added, **Continue on**
  and Failover or Balance move the chat to whichever has room.
- A Claude plan with extra usage turned on (in claude.ai's settings) keeps answering once it is spent, and Anthropic
  bills that usage. Lookout sends such an account nothing past its plan unless **Use extra usage once every plan is
  spent** is on under **Plan use** on Anthropic's page in **Settings › Providers**, and then only once no account has plan room. If a
  reply was served from extra usage while it is off, Lookout stops using that account until its limit resets and says
  so once.
- When the account a turn ran on is spent (or needs a new sign-in) and another of the provider's accounts has room,
  the notice offers **Continue on** that account: the chat moves there and the turn picks back up. Requests already
  move by themselves, so this shows when an account ran out partway through an answer.
- When no account has room, the turn stops on a quiet notice that says which limit is used up (the
  provider's **5-hour** or **weekly** limit when the provider names it, else the model's plan limit) and, when the
  provider gave one, the reset time: with several accounts, the soonest any of them takes requests again, which is
  also when a chat or agent waiting at that limit goes on. **Continue on** under that notice names the best move,
  **Continue on MODEL** (the chat's fallback models first); its chevron lists every model the chat can run now with
  what its plan has left, never one of the spent plan, and one billed per token reads **Per token**. **Wait for the
  reset** waits for it instead ([Try again after an error](https://lookout.arcadia.is/docs/chats#retry)).
- `lookout exec` exits with code 3.

## Keep sign-ins in sync across devices

Signed in to your Lookout account, a provider you connect on one device connects on your other devices too, and
signing out of a synced account signs it out on all of them. Without a Lookout account, each sign-in stays on the
device it was made on. OpenCode's free tier is always set per device.

An account synced to all your devices says nothing more. Otherwise its row says where its sign-in lives:

| Label | Meaning |
|---|---|
| **Syncing** | Being synced with your account. |
| **This device only** | Stays on this device. Hover for why. |
| **From environment** | An environment variable on this device supplies it, so it stays here. Unset the variable to sign out. |
| **Sync needs you** | This device and your account hold different sign-ins, or the sync failed. When they differ, the provider's row says so and its page offers a choice. |

**Sync needs you** offers **Keep this device's sign-in** or **Use your account's sign-in**. A sign-in that came from
another Lookout account offers **Add it to this account**, **Use this account's sign-in** or **Keep it on this device
only**.

When your Lookout account doesn't answer for a while, a notice above the providers says sync is paused and why. It
says **Trying again now** only while Lookout waits on an answer, otherwise when the next try is, and it names any
sign-in you saved here that hasn't reached your account yet. **Try now** tries at once. The notice clears by itself on
the next try that gets through.

On a machine without the app, `lookout providers` lists this machine's providers and settles the same choices.
PROVIDER is a provider's name, in quotes when it has a space:

```sh
lookout providers                      # this machine's providers
lookout providers sync                 # read your account now
lookout providers use-account PROVIDER # use your account's sign-in
lookout providers keep PROVIDER        # put this machine's sign-in in your account
lookout providers keep-local PROVIDER  # keep this machine's sign-in here only
```

## See your usage

Open **Settings › Usage**, or **Usage** in the account menu at the foot of the sidebar. A mark beside **Usage** there
means a provider cannot answer at all: a red alert mark when every account is at its limit, an amber dot when every
account needs a new sign-in.

**Limits** shows what each plan has left, one row per provider however many accounts it has. Anthropic is one row
for its Claude plans and its API key:

- The row's bar has a segment per account: a red one is at its limit (a faint fill on it is what comes back with it,
  such as its week behind a spent 5-hour), a dashed one needs a new sign-in, and under One account or Failover the
  bright one is the account requests go to. Past eight accounts the segments go open ones first, then the spent, then
  the rest; [excluded](https://lookout.arcadia.is/docs/usage#exclude) accounts come last, faint. Point at a segment to see that account's windows.
- Beside the bar, one account says what it has left, such as **Weekly 52% left**. Several say how many can take a
  request and when the next one comes back, such as **1 of 4 open** and **1 back in 1h 15m** (or, when every one is
  nearly spent and none is at its limit, when the first resets).
- **Attention** comes first, only when something needs you: a provider at its limit (with when it resets), an account
  to sign in again (**Sign in again** opens its sign-in here), a sign-in ending within three days, or every account
  nearly spent. An account at its limit while another one answers stays in **Plans**: requests have already moved, and
  its window reopens by itself. A provider that refused requests for its limit, with chats or agents waiting for it,
  is at its limit here until that wait ends. An account read with room since then, such as one you just signed in,
  shows its own windows and the provider reads open, while the waiting chats go on there one at a time. If a request
  sent on such a reading is refused too, the provider stays at its limit until the wait ends, whatever it reads.
- **Balances** lists keys that report money instead of windows: a prepaid balance the provider reports, or budget
  left on a key Lookout meters itself. Budget left is not the provider's remaining credit. An Anthropic API key beside
  Claude plans is a line of Anthropic's row instead, named **API key**, with its budget left or what it spent, to the
  cent.
- Click a row to see each account under its name and plan, a line per window with what is left and when it resets
  (**Resets in 3h 30m** within a day, **Resets Oct 21, 8:22 PM** after that); a used-up window says **Spent** and when it comes
  back. A model's own limit (a Claude plan's **Fable weekly**) gets a line under an account only while it runs out
  before the plan does. A window that can't be used before its account comes back, such as a 5-hour under a spent
  week, is drawn faint. After an account's plan comes how requests reach it, such as **In use by 2 chats** for an
  account chats are working on, or **Primary**. Excluded accounts come after the rest under **Not in the pool**, their bars faint, so **1 of 3 open**
  counts the lines above them. Past eight accounts the list shows the first six (and the bright one); **Show more**
  lists the rest.
  **Manage** opens the provider's page in **Settings › Providers**. The refresh button beside the title reads every account
  again.
- Above an open row's accounts, a line such as **At this pace the weekly limit runs out in about 5h 20m; it reopens
  Sun 20:22** names the window that runs out first for the accounts the provider's **Use** choice can send requests
  to, at the net pace of the last two hours (each window's since it last reset), and when a reset opens one again;
  within a day it counts down, beyond it gives the day. When a short outage would hide a later weekly outage, the line
  adds when the weeks run out and when weekly room returns, or says the weeks last past the eight-day horizon.
  Pools with different plan names say **mixed plans**: the pace sums account percentage points without weighting plan
  sizes. It never shows while the provider holds you at a limit. The composer's usage card shows the same line under its head. An account kept out of automatic
  routing counts on its own line only: it never makes the pool read open. The line shows only when the provider runs
  out ahead; the website's dashboard shows the line your devices last published, and the `lookout usage` command and
  the MCP `lookout_usage` tool carry the same forecast. `lookout usage --follow` prints a line each time an account is
  spent or opens again, a meter drops another 5 points, or the serving account changes, with `ALERT:` lines for what
  needs you ([Follow plan usage](https://lookout.arcadia.is/docs/cli#usage-follow)).
- The website's dashboard reads what your devices publish: the same Limits, with an account that has no plan, one its
  provider refused and one excluded from the pool drawn as here, so its pool counts match the app's.

**History** shows what was spent:

- One row of controls: the period (**24 hours**, **7 days**, **30 days**, **This month**, **Last month** or **Custom
  range**), the grouping (**Model**, **Provider**, and on this Mac **Project**, **Agent** or **Account**), **All
  devices** or **This Mac**, and **Export CSV** in the menu at its end. Signed out of your Lookout account, the page
  shows this Mac only.
- The period's tokens, its turns and the share of input the cache served, then tokens per day with one row per model,
  provider, project, agent or account. A provider is its company, with its mark: OpenAI for ChatGPT, SpaceXSI for Grok, and one
  Anthropic row for its Claude plans and its API key together. Point at a row to light its part of the chart; the list shows six rows, and **Show all** the
  rest.
- **Agent** says whose work it was: an agent's row holds its own chats, the chats it started or was handed and their
  subagents; an app that started chats over MCP (Claude Code) has its own row, and everything else is **You**. An
  agent's own project reads as the agent's name. **Account** splits a turn that several accounts served by what each
  one served. On a plan with weekly limits, **Week** says about how much of the week each row used: by agent, of the
  plan's accounts together; by account, of that account's week. Each account's total is measured from its meter and
  shared among what it served, so the split is an estimate. The `lookout usage --json` command and the MCP
  `lookout_usage` tool carry the same split per owner, and how many chats at each owner's pace the plan keeps going
  until its next reset.
- **Turns** opens every turn in the period, page by page. A turn that failed before any model answered spent no tokens,
  so it is neither counted nor listed. **Export CSV** keeps every row, with a `reached_model` column that is `false` for
  those.
- On **This Mac** every period counts all of its turns, up to a year back, however many there are: Lookout keeps daily
  totals as turns end, so History opens at once.
- On **All devices** your Lookout account adds up every turn each of your devices reported in the period, a device you
  removed included, counting tokens and turns the way **This Mac** does. Each device reports its turns every few
  minutes. The web dashboard's History reads the same totals.

## Related

- [Models and providers](https://lookout.arcadia.is/docs/models.md): Connect the providers you have a plan with or add a custom provider, then pick a model, its effort and its variant for each chat.
- [Account and devices](https://lookout.arcadia.is/docs/account.md): Your Lookout account: signing up, signing in on a Mac, adding a device, the Recovery Key and the web dashboard.
