Skip to main content

Updated 2026-11-07 View as Markdown

Set up a terminal

Connect a terminal to several workspaces and to your own connectors, and run GBrain for a whole team.

Works in
  • Hosted workspace
Used from
  • Its own AI
  • ChatGPT, Claude, Codex or Cursor
Not for a self-hosted install

An AI you connect over MCP reaches one workspace. A terminal reaches as many as you turn on, and the connectors you added that are in none of them: the accounts you connected for yourself, and web search or page reading once you install them. That makes it the way to work across several workspaces at once, say for a team you set up and the people you set up workspaces for.

A terminal’s workspaces come with those workspaces. Your own connectors on a terminal take Tools; without it, the terminal reaches its workspaces and nothing of yours.

Everything a terminal does goes through the same rules as everything else in GBrain: it reaches only what you turned on, every action is recorded, and keys never leave our servers.

Connect a terminal from the browser

Install the gbrainio command, then:

gbrainio terminal connect

It prints a link and opens it. The page lists every workspace you belong to, each Off, with what the terminal may do in it. Turn on the ones it should reach. With Tools, your own connectors are listed below them, every one off: turn on what the terminal may use. A workspace that is no longer active isn’t offered.

The Set up your terminal page. Signed in as brad@example.com, with Switch. Two workspace cards, Hex and Zion, each Off. Under your connectors, Exa, Firecrawl and Perplexity, each on its own ladder at Off. A legend: Read looks things up. Read & Write also changes them. A Connect terminal button.
Each workspace is a card, Off until you turn it on, with three levels. Memory and Schedules are Off, Read or Read & Write. Tools are Off, Mine or Everyone's. With Tools, your connectors are listed below the workspaces, each on its ladder at Off until you turn it on. One you add later joins the terminal turned off.

Press Connect terminal and the page shows one command:

gbrainio terminal connect gbp_…

Run it in the terminal within ten minutes. It works once, and whoever runs it is connected as you, so never share it. If the browser can’t open on that machine (a server over SSH, for example), paste the printed link into any browser and bring the command back.

If the terminal is already connected as another account, it names both and asks before it switches; a yes deletes the other account’s terminal there. --yes switches without asking, and is how a script or an AI switches, since nothing waits for an answer where there is no one to type it. The page that made the code says so the moment you run it.

gbrainio-screen connect-code

Connecting reads back what the terminal is connected to. The number in the ID column is the id -w takes. An email says a terminal was connected and links to its page, so you know even if you weren’t the one at the keyboard.

Or set a terminal up in Tools

To start from the browser instead, open Tools, then Terminals, and press Connect a terminal. Every connector on your account is listed, each on its ladder at Off: turn on what the terminal may use. Add a connector, under the list, connects one you don’t have yet and returns to this page with it listed. Turn on any workspace it should reach, then press Connect terminal. The page shows the same steps: install the command line, then the one command, gbrainio terminal connect gbp_…. The moment it runs, the page says so and hands you the next command, gbrainio tool ls. If the code runs out first, the page says so, and Get a new code makes another.

What this terminal is connected to

gbrainio terminal show answers it on one screen, starting with a sentence. Then the terminal itself: its id (the one in its page’s address), the name you gave it, who it belongs to, when it was connected, when it was last used, and when it ends. Then each workspace it reaches and what it may do there, with the setup page’s level words and two lines saying what they mean, and whether Shell is on for you. Last, the tools it can use, one row per tool and account, each at its level; a tool GBrain holds the key for says Included where an account would be. What each level allows is tool show‘s, one command away.

gbrainio-screen terminal-show

Two workspaces, and what the terminal may do in each. In the terminal, Memory and Schedules are Off, Read or Read & Write (a Personal workspace’s Memory is Off or Read & Write); Tools are Off, Mine or Everyone’s. A terminal you didn’t name has no Name row.

It lists only what this terminal was given. gbrainio tool show lists every connector on your account, including the ones this terminal doesn’t use.

What a terminal reaches in each workspace

Each workspace’s Tools level decides what a tool command runs there:

ToolsWhat a command can run in that workspace
OffThe workspace’s memory and its schedules, nothing else.
MineThat, and your own tools: the ones you added to the workspace and the ones you connected for yourself.
Everyone’sThat, and everybody else’s tools in the workspace. A colleague’s tool runs as them, and the record names you as the one who asked, unless the colleague set it to Everyone, but I approve all requests, or Only me, on their Approvals page (Connect accounts has each).

Memory and Schedules work the way they do for an AI: Read looks things up, Read & Write also changes them. What an AI can reach has the full table.

A terminal that reaches no workspace still runs your own connectors, with Tools.

A terminal’s card under Terminals in Tools names each workspace it reaches and what it reaches there. Each of those workspaces also lists the terminal on its AI & Agents page, beside the AIs you connected to it.

Naming a workspace, and whose copy

With one workspace on, no command has to name anything. With more than one, every tool command names which, with -w. There is never a default among several, so nothing runs in the wrong workspace by accident:

gbrainio-screen several-workspaces

Two or more workspaces, and the terminal asks which. The refusal hands you the command that works.

tool ls -w <id> lists what that workspace lets the terminal run, grouped by whose it is:

gbrainio-screen tool-ls-team

Your tools, then each colleague’s. At Everyone’s, a colleague’s tools are listed under their name with the -u that runs their copy.

When two people’s copies of one tool are both there, Gmail for example, a command stops and lists them, and -u <email> says whose runs: the person’s email, in any case, or their user id, the same id an AI passes as user over MCP.

gbrainio-screen whose-copy

Two copies, and the terminal asks whose. Your own copy on the terminal and your copy in the workspace are one copy. Two accounts of your own are -a, the account, not -u.

gbrainio workspace show -w <id> lists the tools in a workspace and whose each copy is.

-a <account> names one of your accounts, the same way for Google and Microsoft, and is the account an AI passes over MCP:

You haveA command
One accountUses it. Nothing asks which.
Several, and the command lists (gmail message search, outlook message search, gcal event ls)Runs on every one, each result naming its account.
Several, and anything elseIs refused, with a command for each account and its -a.
An -a this terminal can’t useIs refused one way, whether the address is someone else’s or nobody’s, with tool show <name> for the accounts it can use.
An -a this terminal holds, connected without the access the command needs, or disconnectedSays so, with the page that connects it again with that access.

An address is matched in any case, and -a goes with -u on a colleague’s copy. Activity keeps the account each call used: activity ls -a you@example.com.

Reading a terminal back, and changing it

gbrainio terminal show                 # what this terminal is connected to, and what it may do there
gbrainio terminal show --format json   # the same, for an AI to read
gbrainio terminal open                 # the page that changes what it reaches
gbrainio terminal disconnect           # delete this terminal from your account

terminal connect is also how a terminal connects without a browser: run it with a key GBrain handed you for a terminal, gbrainio terminal connect gbu_c_…. A key is for one door: one made for an AI works only where AIs connect, and a terminal’s only in a terminal, so every action on your record says which did it.

terminal show only reads. Changing anything happens on the terminal’s page in the browser, which terminal open opens; in Tools it is under Terminals. Its Connectors tab turns a workspace on or off for it and moves a level, and lists every connector you have, each at Off until you turn it on by its ladder; Remove, under the menu on a card, takes one off the list, and Add a connector puts one back or connects one you don’t have yet, then returns to this page with it on the list at Off. Connection gives it more time, turns it off (Turn off now ends its time now, and giving it more time brings it back), and at its foot deletes it. A change applies from the terminal’s next command. Turning a workspace off ends any shell the terminal had open there.

A terminal's page in Tools, with the tabs Connectors, Activity and Connection. On Connectors: the same workspace cards as the setup page, each with its levels, and every connector the terminal holds, each at Off.
The same cards as the setup page. Each press changes the one card you pressed.

A terminal lasts a year unless you pick less on its Connection tab. Connecting a second terminal on the same computer turns the first one off.

Where a command lives

The commands are shallow, not nested. Each kind of thing is a word of its own (workspace, tool, memory, schedule, user, organization, activity), and a flag says which one you mean: -w a workspace, --org (-o) an organization. workspace holds only what is about the workspace itself: listing, showing, starting, opening and restarting one, and a shell in it. A command that lists or adds things takes the flag of what they belong to (schedule ls -w 7, user ls --org 12). One that acts on a single thing takes that thing’s id, and needs no other flag when the id is unique on its own (user show 42, activity show 52). A schedule’s job and a memory’s page are named inside their workspace, so those keep -w (schedule rm <job> -w 7).

Your workspaces from the terminal

A workspace’s memory and its schedule have commands of their own, named for the workspace with -w, like a tool’s:

gbrainio memory search planning -w 7       # search its memory
gbrainio memory get people/jane-doe -w 7   # one page
gbrainio memory list -w 7                  # its pages, the newest first
gbrainio schedule ls -w 7                  # what it runs on its own
gbrainio workspace restart -w 7            # restart it

The memory commands are the gbrain command’s own, by its names: search, get, list, backlinks and tags. They read; writing a page (put) and asking a question (query, which spends the workspace’s AI credit) aren’t available from a terminal yet, and say so. Only the ones that take words and print an answer are here. Those that read a path or the environment, like import, export and config, say so, and run inside the workspace with workspace shell. stats is left out too: gbrain answers it only to its own admin, and a connection never is one. The schedule’s commands are ls, new, edit, run and rm. edit changes one in place and keeps what you don’t name: schedule edit <job> -w 7 --cron '0 9-18 * * 1-5' moves it to every hour on weekdays, with the same instructions.

On a terminal each answer reads as a person reads it: a page is its title, its text and a few facts; a search is numbered hits; and an empty answer says so (“No pages link to people/jane-doe.”). Piped, or with -f json, it is the whole record the memory answered with.

They answer to the same levels an AI does. The Memory level decides the memory commands, at Read. The Schedules level decides the schedule’s: ls at Read; new, edit, run and rm at Read & Write. Each one is an action on your Activity, like any tool’s, and a refusal names the level and the page that changes it.

A workspace that is asleep is woken first. The command says so, waits while it starts, then runs. One that is stopped for a reason stays stopped: a trial that has ended (the refusal has the page that keeps it), a suspended account, or a workspace being deleted.

Restarting interrupts the chats in progress, so only an admin may, and on a terminal it asks first. With nobody to ask, from a script or an AI, it does nothing without --yes and exits 5.

Your organizations, and their users

People join an organization, and can use the workspaces in it that are not kept to certain people. A terminal reads the organizations of the workspaces it reaches, and their users:

gbrainio organization ls              # those organizations and their ids
gbrainio organization show 12         # its workspaces and its users
gbrainio user ls                      # the users of each of them
gbrainio user show jane@example.com   # one person, in each you share
gbrainio user open --org 12           # the page where they are managed

An organization is one this terminal reaches a workspace of; one it doesn’t is answered as one that doesn’t exist, and so is a person seen in none of them. organization show takes the organization’s id after it, as user show takes a person’s; elsewhere --org names one, or -w names it by one of its workspaces. With one organization none is needed; with several, a command about one stops and lists a ready command for each. Each user is in one state: admin, member, or invited (an admin sees who is invited, as on the Members page). Someone invited is their address alone until they join: no id, no name, whether or not the address has an account, and they are named by email.

A terminal reads; a person on the website changes. Nothing a terminal runs adds, invites, approves or removes anyone, or changes a role. user open opens the Members page, where an admin does. Reading users and restarting a workspace take a terminal you set up in the browser; a key connected with gbu_c_… reaches what that key was given and no more.

Your tools: what you have, and installing one

A tool is the command line’s word for a connector, something GBrain reaches for you, installed and set up: a vendor’s MCP server, Google, Microsoft, a lookup GBrain holds the key for, or a server of your own (Connectors has the kinds). tool is the one word for it, installed or not: tool ls is what this terminal can run, tool search finds one, show is what you have, and install the page that installs one.

Installing finishes in the browser. The terminal never takes a key or a sign-in and never grants anything: tool install opens the page where you do it.

gbrainio tool ls                    # what this terminal can run here
gbrainio tool ls --all              # that, then every one you can install
gbrainio tool ls --available -w 7   # what workspace 7's Install page offers you
gbrainio tool search mail           # the ones whose name or work says "mail"
gbrainio tool search notion --all   # installed or not
gbrainio tool show                  # every tool on your account, and where
gbrainio tool show notion           # one in full: what it does, how it connects, your copies
gbrainio tool install notion -w 7   # open the page that installs Notion in workspace 7
gbrainio tool install -w 7          # open workspace 7's Install page, the whole store
gbrainio tool install custom -w 7   # open the page for a server of your own
gbrainio tool install notion        # with no workspace: the page that connects Notion on your account

A terminal that reaches no workspace installs on your own account: the same line with no -w opens your own page for the connector.

How tool listings work

Every tool command that lists tools, tool ls and tool search, works one way. It lists what is installed and this terminal can run, unless you ask for more; --installed says so out loud. --all lists that, then every tool you can install. --available lists only the ones you can install. The three mean the same on both commands, and none has a short form, since -a is --account everywhere. A list of what is installed opens with the account the terminal is connected as, ends with the same line, the command you typed with --all after it, and an empty one says so in one line.

gbrainio-screen tool-ls-empty

Nothing installed yet. One line, and the command that shows what you can install. When you have tools this terminal can’t use, it says that instead and adds terminal open, where you change what it reaches.

What you can install is every listing you could install, less one you have already unless its vendor allows a second account. With -w it is what that workspace’s Install page offers you, less what you installed there yourself: a colleague’s copy never hides one. A vendor that has to approve GBrain first isn’t offered, since an install could only fail. JSON keeps one shape for each flag: no flag is the list of what is installed, as it always was; --available is available; --all is installed and available.

gbrainio-screen tool-ls-available

What workspace 2 can install. Every listing its Install page offers, one line each; -f json holds the whole of each.

tool search takes words and keeps the ones each of them is in, ignoring case: a tool’s name, what it is, its category, what it does and its description. Two words find what has both. Nothing installed matching says so, with how many you could install; nothing matching at all is refused, with tool ls --all to see everything.

gbrainio-screen tool-search

What in workspace 2 has to do with issues. Sentry twice, Brad’s and Jamie’s, and Jamie’s Linear; --all would add the ones that could be installed.

show lists the tools installed on your account, one account a row, including the ones this terminal doesn’t use, each with the workspaces this terminal reaches that it is in. A workspace the terminal wasn’t given is counted, never named. One whose vendor turned the sign-in away says it needs reconnecting, with the page that does it. show, and ls --available or --all without -w, take a terminal you set up in the browser: a key connected with gbu_c_… reaches what that key was given and no more.

gbrainio-screen tool-show

Every tool on the account, one row per tool and account. ACCOUNT is what -a takes to name one: an address, a server’s name, or Included. LEVEL is this terminal’s, Off spelled out, and SHARED INTO says Nowhere rather than leaving a gap.

show with a name is every copy of that tool this terminal can see, one account a row: yours, and a colleague’s in a workspace where this terminal’s Tools are at Everyone’s. A copy is whose it is and which account, and the flags a command already takes name it: -a <account> is which account (the ACCOUNT column leads each row, because it is what -a takes) and -u <email> whose (the WHOSE column says the person in words). With several accounts the level is a column, and the ladder is printed once under them, each level with the sentence the permissions page uses for it. gbrainio tool show gmail -a you@example.com shows that one in full: the account, whose, where it is shared, whether it works, and every level with what it allows and the one this terminal holds marked. The same -a and -u pick the same copy when a command runs. One Google sign-in gives three tools, Gmail, Calendar and Drive, so tool show gmail is headed Gmail, with the Google account it comes with, and tool show google is the account: a block for each, one row per tool it gives, its level and what that lets it do, Off spelled out. tool help gmail and tool install gmail say the same. Which commands each level unlocks is tool help.

gbrainio-screen tool-show-copies

Every copy of one tool. Sentry is in Hex twice, Brad’s and Jamie’s: one row each, the level in its own column, and the ladder once underneath.

gbrainio-screen tool-show-one

A Google account, the tools it gives. Each tool its own row, its level, and what that level lets it do; Off is a word, so a level left off never looks like missing data.

gbrainio-screen tool-show-gmail

One account in full. The account and whose, where it is shared and whether it works, then each level with what it allows, the one this terminal holds marked in words.

install prints the page’s address, opens it, and says how the tool connects. The workspace is the one -w names, or the only one there is; with several and no -w, it stops and lists them, with the command for the first. The page is the one the tool’s own button on the workspace’s Install page opens: a server’s install page, and for Google and Microsoft the Install page itself, where Sign in starts, and for a key of your own the workspace’s page that asks for the key. One you have already still opens, and says so: it is how a second account is added. A tool installed on your account rather than in one workspace, like Exa, opens your account’s Connectors page. Once it is installed, tool ls lists it on the next command, with no need to connect again.

gbrainio-screen tool-install

The address first, then the browser. Linear’s install page in Hex, where signing in with Linear finishes the install, and a note saying how it connects.

Every tool is in one state, and each command says which:

Statetool lstool ls --availableRunning it
Not installedNot listedListedSays it isn’t installed, with the tool install that does it. tool help still shows its commands.
Yours, and this terminal can use itListedOnly if the vendor allows a second accountRuns
A colleague’s, in a workspace at Tools Everyone’sListed under their nameListedRuns as them; -u says whose when several share it. Unless the colleague set it to Everyone, but I approve all requests, or Only me: then it waits for their approval, or isn’t yours to run
Yours, and this terminal can’t use itNot listedOnly if the vendor allows a second accountSays why: Tools are Off there, it is in a workspace this terminal doesn’t reach, or it was taken off this terminal. terminal open changes that.
Needs reconnectingListedAs yoursRefused, with the page that connects it again
Yours, and the account has no ToolsListed, marked Needs Tools, with a note naming the account and the page that gets ToolsAs yoursRefused: Tools required. terminal show marks it the same way
A channel: Slack, TelegramNeverNeverRefused, with the page in each workspace that connects it

What this terminal may run

gbrainio tool help <name> starts with what the tool is, from its listing: what it is, how it connects, what it does, and a paragraph or two. Then its commands, and under them the same commands grouped by what unlocks them on this terminal, in the workspace -w names: what you can run now, at the level held, then what each higher level would add (At Draft you’d add, At Read & Write you’d add). A command a refusal turns away says the level the same way: Needs Gmail at Read & Write, fixed by Raise Gmail to Read & Write for this terminal, on the page the refusal prints. The terminal never raises it itself: a person does that on the page, in the browser. -f json gives the same marks to a program, one object a command, each with the needs the refusal says.

gbrainio-screen tool-help

What gmail is, and what each level unlocks. Gmail is at Read here, so search, show and the lists run now; each command that writes is under the level that would add it, and tool gmail open is the page where a person raises it.

Slack and Telegram are channels, places people talk to a workspace, so show, install and running one refuse them and print the page in each workspace that connects them, without opening it.

When the command line says no

What it printsWhat happenedExit
This terminal isn’t connectedIt was never connected here, or it was deleted. Run gbrainio terminal connect.4
This terminal is connected as …You ran a code for another account where nothing could answer its question. Nothing changed. Run it again with --yes to switch, or gbrainio terminal disconnect first.5
This terminal is expiredIts time ran out, or it was turned off on its page. Turn it back on there: the refusal prints the page, and gbrainio terminal open opens it.4
This terminal reaches N workspaces. Name one with -wAdd -w and the id.2
2 people share … here. Name one with -uTwo people’s copies; add -u and the person’s email.2
No tool named …Nothing by that name is on the terminal, in the workspace, or in the store. gbrainio tool ls lists what is.2
… isn’t installedIt is in the store, and you haven’t installed it. The refusal prints the gbrainio tool install that opens its page.3
This terminal can’t use …You have it, and this terminal can’t run it here: Tools are Off there, it is in a workspace this terminal doesn’t reach, or it was taken off this terminal. gbrainio terminal open changes what it reaches.4
… needs signing in againIts vendor turned the sign-in away. Connect it again on the page the refusal prints, then run the command again.1
… isn’t a Google account this can useThe -a names an account this terminal doesn’t hold. gbrainio tool show gmail lists the ones it does; a person adds one on the page the refusal prints.4
… is on this terminal without … accessThe account is here, connected without what the command needs, or it was disconnected. Connect it again with that access on the page the refusal prints.4
Schedules is Read for this terminal in …The command takes a higher level. gbrainio terminal open changes it.4
…’s trial has ended, so it is stoppedKeep the workspace on the page the refusal names; nothing in the terminal wakes it.4
This workspace is no longer activeIts trial or subscription ended, or the account that pays for it is suspended. The refusal names the page that keeps it, or support.1
Tools requiredThe command reaches your own connectors, and the account the terminal is connected as doesn’t have Tools, or Tools has ended for it. The refusal names that account by its email, and the page that gets Tools. A workspace’s connectors still work.1
Only an admin can restart …The refusal names the admins.4
Restarting … needs –yesNothing ran. Run it again with --yes.5
This terminal reaches N organizations. Name one with –orgAdd --org and the id, or -w and one of its workspaces.2
No organization …That id is not one this terminal reaches. gbrainio organization ls lists them.3
… isn’t available yetThe command is held back for now. Nothing ran, and nothing else is offered in its place.2
… isn’t a toolThe name is not one gbrainio tool ls --available lists. A typo names the one meant.3
Slack isn’t a toolSlack and Telegram are channels, connected on a workspace’s own page. The refusal prints that page for each workspace; open one in a browser.2
… has to approve GBrain firstNothing opens. The refusal has the page where you ask us about it.1
Your tools are read from a terminal set up in the browserA key connected with gbu_c_… reaches what that key was given and no more. One that connects to one workspace runs what its Tools level there reaches, and the refusal prints tool ls -w for it. Run gbrainio terminal connect to read your own.4
application … is tool … nowThe store’s commands are tool commands. Run the one it prints.2

Exit 2 is a mistake in the command, 3 is something that doesn’t exist, 4 is something this terminal may not do, and 5 is a change that waits for --yes. A refusal ends with the command that fixes it when there is one, and refusals go to stderr, so gbrainio … | jq or | tar never swallows one.

For an AI in the terminal

An AI running in the terminal can read what it may do without asking you:

gbrainio terminal show --format json
{
  "person": {"name": "Brad Gessler", "email": "brad@example.com"},
  "terminal": {"id": 34, "name": null, "paired_at": "2026-10-05T18:40:00Z",
               "last_used_at": "2026-10-07T09:12:00Z", "expires_at": "2027-10-05T18:40:00Z"},
  "workspaces": [
    {"id": 7, "name": "Hex",
     "memory": "read", "schedules": "read", "tools": "all", "shell": false}
  ],
  "applications": [
    {"application": "Exa", "account": null, "levels": {"search": "on"}, "included": true}
  ],
  "url": "https://gbrain.io/users/7/connections/terminals/34"
}

A workspace’s id is what -w takes and tools is its Tools level. The terminal’s id is the one its page’s address names, and its name is null until you name it. Each entry under applications also lists the tools it gives, by the word tool show takes, with the capability its level is keyed by and that level in words ("tools": [{"tool": "gmail", "capability": "gmail", "says": "Read"}]), and select, the -a that names it. workspace show prints a workspace and its tools with the same keys, and tool show every one on your account. The keys are a contract: they are added to, never renamed. It can’t change any of it; terminal open hands the page to you.

Every command

Three levels, each showing what is under it:

gbrainio tool ls -w 7                   # the tools this terminal can run in a workspace
gbrainio tool show                      # your installed tools, one row per tool and account
gbrainio tool show gmail                # every account of one, and what each level allows
gbrainio tool help gmail                # what it is, and each command, allowed or not here
gbrainio tool gmail message search -h   # one command's arguments
gbrainio tool install -w 7              # the page that installs one

Then call one. Web search and page reading (Exa, Firecrawl, Perplexity) are in the store: install one and the terminal has it on its next command, as an AI does.

gbrainio tool exa search "planning agendas"
gbrainio tool firecrawl scrape https://example.com
gbrainio tool perplexity research "what has the SF planning commission approved this year"
gbrainio tool gmail message search "invoices from June" -w 7
gbrainio tool gdrive file search "board deck" -w 7
gbrainio activity ls                # your recent actions
gbrainio activity ls --tool gmail   # only gmail's, on this terminal
gbrainio activity show 52           # one action in full
gbrainio workspace ls               # your workspaces and their ids
gbrainio workspace show -w 7        # one workspace: its facts, its tools and whose

Anything ending in open prints the address first and then opens your browser, so it also works on a machine with no browser.

A tool’s permissions, the page that changes them, and what this terminal did with it are each one command from the others. tool show gmail is the level each of your accounts is at, and what every level allows; tool help gmail groups each command under the level that unlocks it. Both end with tool gmail open, the page where its permissions on this terminal are changed, and activity ls --tool gmail, what this terminal did with it. --tool takes a name the way tool help does (gmail is its commands, google every Google one, gmail_search the one), -a narrows to one account, and both page with --limit and --cursor. activity open takes them too, as far as the Activity page can: one command, or one account of yours.

Every argument a tool takes is also a flag, so you can say what you want one piece at a time:

gbrainio tool gmail message search --from billing@stripe.com --newer-than 7d --unread -w 7
gbrainio tool gmail draft new --to jenny@example.com --subject "Tuesday" --body "Works for me." -w 7
gbrainio tool gcal event ls --query standup -w 7
gbrainio tool gdrive file export <id> -f pdf -w 7 > ~/Desktop/deck.pdf

A file moves through standard IO, never a path. One a tool hands back comes out on stdout as its bytes, a piece at a time as it arrives, so redirect it (> deck.pdf) or pipe it; on a terminal it is refused rather than printed. One a tool takes goes in on stdin, given as -: --eml - < message.eml, --file - --name deck.pdf < deck.pdf, or several at once as one tar stream, tar cf - a.pdf b.png | … --attachments -. The command line reads no path and writes no file on your machine.

Many files at once is a short loop on your machine, piping each in:

for f in ~/Desktop/receipts/*.pdf; do
  gbrainio tool gdrive file upload --file - --name "$(basename "$f")" < "$f"
done

These work the same way on every command:

-w, --workspace <id>        which workspace, when the terminal reaches several
-o, --org <id>              which organization, when the terminal reaches several
-u, --user <email>          whose copy, when several people share one tool
-a, --account <email>       one of several connected addresses
-f, --format json|text|eml  readable text on a terminal, JSON when piped
-d, --dry-run               what a call would do, without running it
-h, --help                  what this command takes
--                          the end of the flags: what follows is text

A flag a command doesn’t take is an error that lists the ones it does, so a mistyped flag never ends up inside a search. The email, calendar and Drive commands in full are on Tools, from anywhere.