> ## Documentation Index
>
> Fetch the complete documentation index at: https://lithi.ai/llms.txt
>
> Use this file to discover all available pages before exploring further.

---
title: Use the Lithi command line
description: >-
  The released Lithi commands, split by whether they stay on your machine or reach
  Lithi. Covers protected credentials, machine-readable output, and why assessment
  never runs work.
route: /docs/compute/clients/cli
page_id: docs-compute-clients-cli
page_type: howTo
content_layer: guided documentation
surface_profile: guided_docs
audience: Operators and developers scripting Compute from a terminal
voice: D
reader_question: Which commands are safe to run, and which ones actually spend money?
primary_action: Practice the whole flow in the sandbox
source_locale: en-US
source_status: APPROVED
source_version: docs-compute-clients-cli-en-us-2026-09-05-v1
last_updated: '2026-09-05'
robots: index
claim_registry_pinned: true
claim_registry_resync: "npm run governed:tsx -- scripts/build-compute-public-claim-registry.ts --write"
---

## Install and protect your credential

This page prints no install command. The released version and the platforms it is tested against are published on the compatibility matrix, because they move with each release.

Keep your work key in your operating system credential store or your team's secret manager, and point the command line at that reference. Never pass a secret as an argument; arguments are visible to other processes and are captured in shell history.

Your base URL and current API version appear in the portal under developer settings, and in the API description you download. Confirm which account resolved before your first real submission.

```bash
lithi doctor
```

## Commands that stay on your machine

These read your own files and send nothing. They cost nothing and cannot spend.

- `lithi assess` — check whether a task fits before anything is sent.
- `lithi inspect` — read the structure of your own input.
- `lithi media inspect` — read the properties of a local media file.
- `lithi transcript plan` — plan a transcript job from a local recording.
- `lithi dataset validate` — validate a dataset against a schema.
- `lithi workflow compile` — compile a workflow request locally.
- `lithi pack compile` — compile a pack locally.

## Commands that read from Lithi

These reach Lithi and change nothing. Run them freely.

- `lithi workflow list` — list the workflows available to your account.
- `lithi workflow explain` — read one workflow's descriptor and declared bounds.
- `lithi status` — read the current state of a job or batch.
- `lithi batch wait` — wait for a batch to reach a terminal state.
- `lithi result download` — download a completed result bundle.
- `lithi eval report` — read an evaluation report.
- `lithi doctor` — confirm the credential and the account it resolved to.

## Commands that cause a remote effect

- `lithi quote` — prices prepared work and returns a signed, expiring quote. It runs nothing and spends nothing.
- `lithi run` — submits work you approved. This spends.
- `lithi batch submit` — submits an approved batch. This spends.

Assessment and execution are different acts. `lithi assess` tells you whether the task fits, `lithi quote` tells you the maximum charge, and only `lithi run` and `lithi batch submit` execute anything.

## Read the exit code and the envelope correctly

A zero exit means the command completed its own act. It does not mean your work succeeded, and a succeeded job is a state you read, never a code you infer.

Each command lists its own exit codes in its `--help`. Do not carry an assumption between commands.

Machine-readable output carries the response envelope: `request_id`, the operation, the contract release, a typed state, an evidence class, `observed_at`, `valid_until` and a structured `next_action`. Parse those fields and branch on the typed state. Never parse the human-readable text, and never trust a read past its `valid_until`.

## Practice the whole flow first

The sandbox runs the same commands against synthetic inputs, so you can rehearse without spending.

```bash
lithi sandbox open --scenario ai-eval-team-v1
lithi configuration plan --sandbox desired-config.yaml
lithi configuration apply --sandbox <plan-id> --expected-digest <digest>
lithi batch --sandbox --workflow eval.semantic_grade.v1 --input synthetic://evals/v1
lithi result --sandbox <job-id>
lithi sandbox reset
```

Read [what the sandbox does and does not simulate](/docs/compute/sandbox/quickstart), and check [your version on the compatibility matrix](/docs/compute/clients/compatibility) before scripting against a command.
