pinecall · Pinecall Docs

pinecall <group> [args]. Every verb, what it is for, what it takes, and what it prints. The endpoints underneath are the gateway API — the runtime repo's docs/protocol/gateway-api.md — and this CLI is a client of that contract and of nothing else, so anything here is something your own code can do too. Which environment a verb acts in, and what is yours against what is the org's, is one page: environments-and-teams.md.

One module per group, imported only when it is asked for: pinecall prompt must not pay for a websocket client. pinecall with nothing after it prints the whole CLI on one screen, built verbs and planned ones alike; pinecall <group> --help prints that group's flags, after a subverb too (pinecall memory policy --help); and pinecall --version (-v) prints the version installed.

Terminal

npm i -g pinecall                 # the CLI, once per machine, for every language
pinecall start                    # in the project's directory: the process you deploy

The CLI never loads the framework. A TypeScript agent is served by the project's own @pinecall/agents — the version it pinned, found from the project's root — and a project without it is refused by name; a Ruby agent by the pinecall gem, a Python agent by the pinecall package in the project's own .venv.

In a checkout the CLI runs from source through tsx (bin/pinecall.js); what npm installs is the compiled dist/index.js and needs no loader.

Running the gateway yourself, from nothing? The runtime repo's docs/from-zero.md is that path end to end, with every output under it.

The map#

verb	what it is	needs the gateway
`new`	a new project of one agent, in TypeScript, Ruby or Python	no
`link`	this project's folder to one of your orgs: your key, written to its `.env`	yes
`start`	the app registered and answering — the process you deploy	yes
`console`	the platform's console in a browser, signed in: the sandbox's at `<url>/sandbox/`, `--prod` for production's at `<url>/`	yes
`chat`	the same app in this terminal, and a written caller against it	yes
`prompt`	the exact prompt a state would produce, offline	no
`test`	the goldens (said out loud with `--voice`), through the agent served from this terminal	yes
`simulate`	a model plays one caller, live, and the call is judged at hang-up	yes
`eval`	one real call re-checked by code	yes
`sessions`	the calls this agent has run, and one of them whole	yes
`runs`	the suites: list, show, diff, promote a call, watch the drift	yes
`cases`	the org's dataset — real calls kept as cases: list, show, approve, dismiss, reopen, pull, keep, forget	yes
`agent`	the agent's settings — yours, the team's, production's — set, knowledge, history, diff, rollback, pull, push	yes
`lexicon`	an agent's words: how the voice says them and what the ears must know	yes
`pipeline`	what it hears, decides and speaks with, as the next call would be built	yes
`line`	which phone is yours, and whose terminal a call from anybody else's rings in	yes
`numbers`	which number reaches which agent, in the environment it answers in, and which the org's accounts own free	yes
`carriers`	the org's carrier accounts — a Twilio account, a SIP peer, a WhatsApp number — where its numbers live	yes
`personas`	an agent's synthetic callers: Pinecall's switched on or off, its own written, generated, tried, pushed	yes
`judges`	every judge a call meets — Pinecall's switched on or off, the org's own, the agent's own: list, add, on, off, rm, try	yes
`judging`	whether the org's calls are judged, and the model the judges run on: Pinecall's, or one of yours	yes
`docs`	the documents the agent searches: push, list, drop, eval, attach, detach, attached	yes
`memory`	what memory kept about a contact, forgetting it, and recall's golden	yes
`remember`	the extraction goldens: what a hang-up makes of a call	yes
`supervise`	listen in on a live call and move on it	yes
`providers`	every vendor this build runs, and the keys this org brought	yes
`voices`	a vendor's voices in a language, and one of them played here before it is chosen	yes
`callbacks`	the numbers people left when every seat was taken	yes
`data`	the org's data: erasures and their trail, its policy, consent, the do-not-call list, export	yes
`deploy`	this project run by the platform itself: uploaded as a release, installed and started there; list, releases, rollback, logs, stop, start, rm	yes
`secrets`	the values the org's hosted apps are started with: list, set, rm — never read back	yes
`login`	sign this machine in through a browser; `link` asks for it when it is needed	yes
`whoami`	which gateway, which org, which environments the key opens, and where the key came from	yes
`mcp`	the MCP server an assistant runs this CLI as; `mcp install` adds it to every assistant here	the tools do

--prod is no verb's and every verb's: anywhere on the line, it runs that one command in production (below) — and a verb that asks no gateway anything, prompt, refuses it instead of accepting an environment it never visits.

Declared and not written: observe, costs, call, tokens. Typing one prints <verb> is not built yet: <what it is for> and exits 0 — a person who types a verb deserves better than "unknown command". src/groups.ts is the one place that says which half of the CLI is still a design, and a verb leaves that table in the commit that writes it.