TT CLI

tt is one terminal for local Tuned Tensor workflows: a laptop-local conversational agent, CUDA fine-tuning, held-out evaluation, artifact verification, and OpenAI-compatible serving on hardware you control.

Installation

On Linux or macOS, the installer bootstraps Node.js 22.19+ if needed and puts tt on your PATH. Local training additionally needs uv and a supported NVIDIA CUDA host; the locked Python runner ships with the npm package and is prepared on first use.

curl -fsSL https://tunedtensor.com/install.sh | sh
tt --version

Inspect the script first with curl -fsSL https://tunedtensor.com/install.sh | less. Pin a dist-tag or version on sh, not curl: curl -fsSL https://tunedtensor.com/install.sh | TT_VERSION=beta sh or TT_VERSION=0.13.0. If npm's global prefix is not writable, the installer uses ~/.local.

Or install the npm package directly:

npm install -g --ignore-scripts @tuned-tensor/cli
tt --version

Uninstall with the same tool that installed it:

# curl installer or npm
npm uninstall -g @tuned-tensor/cli

Run from source:

git clone https://github.com/tunedtensor/tuned-tensor-cli.git
cd tuned-tensor-cli
npm install
npm run build
npm link

Command surface

tt                     # open the conversational terminal
tt shell               # same, explicitly
tt status              # local project context (no GPU probe)
tt init                # scaffold tunedtensor.json
tt doctor              # preflight GPU, uv, and spec
tt validate            # validate the spec
tt run                 # train, evaluate, and write the paired report
tt runs list|report    # inspect local runs
tt models …            # prefetch, verify, serve, activate
tt serve               # OpenAI-compatible local server
tt pipeline …          # composable local train/evaluate/compare plans
tt agent …             # configure the laptop-local TT agent

Explicit commands remain non-interactive for scripts and CI. tt --help lists the full surface. Hosted commands are unregistered. tt local … remains as a hidden alias; new scripts should call the root names above.

Agent shell

The agent harness and conversation state run on your laptop. Inference uses the provider and model you select. Open the shell first; workflow commands work immediately. Use /login to save a provider API key, then /model to choose a provider and model before chatting.

tt
› /model
› /login openai
› /model openai
› /model openai/gpt-5.6-sol

/loginasks which provider, then prompts for that provider's API key with hidden input and stores it in ~/.config/tuned-tensor/agent/auth.json. Custom model definitions live in ~/.config/tuned-tensor/agent/models.json (or the XDG equivalent). /login <provider> skips the provider prompt. Other catalog providers remain available as /login <id> or /model <id>. tt has no provider-secret flags and does not read ~/.pi/agent/. After a key is saved, scripts can still select a model non-interactively:

tt agent models --all
tt agent configure --provider openai --model gpt-5.6-sol --thinking high
tt agent status

--thinking accepts off, minimal, low, medium, high, xhigh, or max. Override selection per process with TUNED_TENSOR_AGENT_PROVIDER, TUNED_TENSOR_AGENT_MODEL, and TUNED_TENSOR_AGENT_THINKING. These values are not credentials.

Ordinary sentences go through the locally orchestrated model session. The model has no shell or general filesystem tool. Known commands such as runs list, doctor, and models list still execute directly. Prefix a command with : to make that intent explicit.

› What happened in my latest training run?
› runs list

Conversations persist under ~/.config/tuned-tensor/agent/threads (or the XDG config equivalent). Use /new, /threads, and /resume <id>. Spec creation waits for /approve, requires at least two examples, and never overwrites an existing path. /reject never mutates. Starting or cancelling training remains an explicit CLI command.

/model shows and changes the TT agent model, not the fine-tune base. List providers with /model, list one provider with /model <provider>, search with /model <query>, or switch with /model <provider>/<model>. /login saves a provider API key.

Quick examples

Train locally

tt init --name "Support Adapter" --model Qwen/Qwen3.5-2B --profile spark
tt doctor tunedtensor.json
tt validate tunedtensor.json
tt models prefetch tunedtensor.json
tt run tunedtensor.json
tt runs report <run-id>

See Local Training for GPU requirements, verification, activation, and serving.

Inspect runs and models

tt runs list
tt runs report <run-id>
tt models list
tt models verify local-<run-id>
tt models serve local-<run-id> --config local-runner.json
tt status

Use tt --json when a script needs to parse command output. Compact run status is the default list; there is no --summary flag on the local tt runs list.

Pipelines

A pipeline is an ordered JSON recipe. Version 1 supports train, evaluate, and compare steps on the local host.

tt pipeline init --file pipeline.json
tt pipeline validate --file pipeline.json
tt --json pipeline plan --file pipeline.json
tt --json pipeline run --file pipeline.json \
  --spec tunedtensor.json --config local-runner.json

tunedtensor.json

tt init scaffolds a tunedtensor.json file in the current directory. Edit it, keep it in version control, and run from that file. Field-by-field guidance is in the spec file guide.

Configuration

Agent conversations and CLI state live under ~/.config/tuned-tensor/ (respects XDG_CONFIG_HOME). In 0.13.1-beta.1, provider credentials live in ~/.config/tuned-tensor/agent/auth.json; stable 0.13.0 reads ~/.pi/agent/auth.json. There is no Tuned Tensor API key.

• --json — output raw JSON
• --no-color — disable colors
• -h, --help — show command help

See also

• Quickstart — first local run
• Agent — shell, approvals, and skill.md
• Local Training — GPU setup and serving