One CLI for all of Smoo AI.
Plus an AI assistant of your own.
th is the single command line for the entire Smoo AI platform— config & secrets, LLM-gateway keys, auth clients, orgs, agents, knowledge, observability, testing, and work-tracking, all behind one binary. It's also home to Big Smooth, an always-on personal AI assistant that lives on your machine.
One ~10 MB Rust binary — no Docker, no Node runtime, no per-project setup ritual. th config, th llm, th api, and th orgwork the moment it's installed. th up starts Big Smooth; drive it from your terminal with th code or your browser with th web.
$ brew install SmooAI/tools/th
$ th up
# or: curl -fsSL https://raw.githubusercontent.com/SmooAI/smooth/main/install.sh | shEvery Smoo AI surface, one binary.
Reach for th before curl, before the dashboard, before Supabase Studio. Config and secrets, LLM-gateway keys, auth clients, orgs, agents, knowledge, observability, testing, and work-tracking all live behind the same command — no per-service installers.
th configConfig, secrets, and feature flags across every environment — the replacement for the deprecated smooai-config CLI.
th llmOrg LLM-gateway keys for llm.smoo.ai — create, rotate, list, overview, and inspect spend.
th api keysAuth clients: M2M secrets and B2M browser keys, scoped by allowed-origin.
th orgList, switch, and inspect the organizations you belong to.
th api agentsManage the AI chat agents serving your org over the platform REST API.
th api knowledgeKnowledge bases and ingestion — what your agents know.
th api observabilitySource maps and telemetry for everything running on the platform.
th testingReport CTRF or JUnit results and manage runs, cases, and environments.
th pearlsBuilt-in work tracker — create, dispatch, push, pull, and sync to Jira.
th jiraBidirectional Jira sync — pull SMOODEV issues into pearls, push updates back.
th auth · th api whoamiYour Smoo AI identity — Supabase user or M2M service account (--m2m).
th cast modelsInspect the live LLM roster your gateway exposes — aliases and model groups.
Durable by default — long-running work on Temporal
The automations that outlive a single request run as durable, resumable Temporal workflows — multi-step outbound engagement sequences, CRM and analytics sync, and other side-effect-bearing flows. They survive restarts and pick up exactly where they left off, keeping their place across days, not just requests.
Authenticate once with th auth login (or th auth login --m2m for a service account), then every command acts on your active org.
Meet Big Smooth.
The wave of personal AI assistants keeps growing — Hermes, OpenClaw, and the rest. Big Smooth is our take, with one difference that matters: it runs on your machine, on the models youchoose, and its code is open. An always-on agent that does real work, remembers what it learned, and never asks you to ship your files to someone else's cloud.
Chat in your terminal or browser
A streaming coding TUI (th code) and an embedded web dashboard (th web). Tool calls render inline as they run — you watch the work, not a spinner.
It does real work
Read, search, write, and edit files; run shell commands; dispatch coding tasks and drive them to green. Not a chatbot that hands you snippets — an agent that ships the diff.
Dependency-aware work tracking
Pearls: a built-in tracker with a real dependency graph, backed by embedded Dolt. Git-syncable across machines, with two-way Jira sync.
Bring your own models
Any OpenAI-compatible provider — Anthropic, OpenAI, Google, OpenRouter, Kimi — plus local models via Ollama. Route each activity (coding, reasoning, fast) to a different model.
Memory that survives restarts
Sessions resume where you left off. Project memories and work items are Dolt-backed and travel with your repo over git — the assistant remembers what it learned.
Agent-to-agent mail
Register a name and coordinate with other agents and sessions — any machine, any harness (Claude Code, opencode, a shell loop). th msg / th agent, backed by the same Dolt store.
Safety built in
Narc watches every tool call for secrets, prompt injection, and stray writes; a permission engine gates the rest with allow / ask / deny; everything lands in the audit log.
Extend it without a rebuild
Add MCP servers (Playwright, GitHub, filesystem…) and file-based CLI-wrapper plugins — globally or per project. Project entries shadow global ones.
Supervise Claude Code
th claude keeps a Claude Code session alive through the account-wide rate-limit throttle — backing off with jitter and resending the last message until it lands.
Open source, on your machine
One ~10 MB Rust binary, MIT-licensed, zero runtime deps. Big Smooth runs where you run it — as a foreground process or an always-on background service — not in someone else’s cloud.
Your files. Your models. Your machine.
Big Smooth is a local process — start it in the foreground with th up, or install it as an always-on background service. You chat over the terminal TUI or the web dashboard; it drives an agent loop with real tools, gated by a safety layer, and keeps durable memory in an embedded Dolt store that travels with your repo over git.
One agent, one governor, tests as the finish line.
When Big Smooth takes on a coding task it handles its own inner iteration (LLM → tool → LLM …). A thin outer governor feeds last run's test output back in, snapshots the workspace when failing tests drop, and stops on the first convincing signal.
Agent reports all tests passing.
Previous turn reached ≤3 failing; this turn didn't improve. More iteration likely regresses.
Next turn would blow the --budget-usd cap.
Safety ceiling (default 5) — not the primary brake.
Stop conditions are budget + plateau, not a fixed iteration cap.
An agent with real tools needs a real leash.
Big Smooth can read your files and run your shell — so four things watch what it does. Surveillance catches the dangerous stuff, a permission engine decides what needs your sign-off, structured logging streams to the dashboard live, and an audit trail keeps the receipts.
Narc
Surveillance. Watches every tool call and incoming prompt — secret detection, prompt-injection guard, write guard. A fast regex path catches the obvious cases; an LLM judge weighs the gray ones.
Policy & permission engine
The gate. Allow / ask / deny for every action, Claude-Code-style modes. Deterministic rules, no LLM — it decides what runs on its own and what needs your sign-off first.
Scribe + Archivist
The record. Structured, trace-linked logging from every actor, aggregated into one live event stream the web dashboard subscribes to for real-time updates.
Audit trail
The receipts. Every tool invocation is written to a rotating audit log under ~/.smooth/audit/. th audit tails it, so nothing the assistant did is a mystery after the fact.
Because you self-host, there's no untrusted tenant to defend against — the safety layer is about keeping your assistant honest with your secrets, your repo, and your network.
One key, every model — or none at all.
Point Big Smooth at the Smoo AI gateway (llm.smoo.ai) for one key across every model, bring your own upstream, or run entirely local models through Ollama. Route each activity — coding, reasoning, fast — to whichever model fits.
Any OpenAI-compatible provider
Pin each activity to a different upstream via th routing, th code's model picker, or ~/.smooth/providers.json. Nothing is hardcoded — swap a model without touching the workflow.
Your assistant remembers what it learned.
Record a durable note with th pearls remember; prime a fresh session with th pearls prime. Codebase conventions, gotchas, the working command, the path to that one weird config file — they stick, because the store is embedded Dolt in your repo and syncs across machines over git.
$ th pearls remember "this repo uses
cargo-zigbuild for aarch64-musl"
# ...next session, cold start:
$ th pearls prime
# → in-progress + open pearls + memoriesLives on your machine — reachable from your phone.
Review a task from your phone. Drive your laptop's Big Smooth from your office machine. Smooth dials a reverse tunnel out to a Smoo AI-operated rendezvous and gives you a stable HTTPS URL at <slug>.th.smoo.ai.
TLS terminates at the Smoo AI edge on a valid wildcard — your laptop never opens an inbound port. The tunnel adds reachability, not authorization: Big Smooth still enforces the same auth locally and over the tunnel.
The command surface.
Your assistant, the platform API, config and keys, work tracking, models, agents and extensions, service and health — every workflow behind the same binary. No separate installers, no Docker Compose, no per-project runtime juggling.
Your assistant
th upStart Big Smooth — the orchestrator behind the TUI and web dashboard.
th codeInteractive coding assistant (ratatui TUI). Same as running th with no args.
th webOpen the Smooth web dashboard in your browser.
th status · th downSystem health, then stop when you’re done.
Platform API
th api agents · knowledge · observabilityThe REST surface of api.smoo.ai, typed and authed for you.
th org list / switch / showMove between the organizations you belong to.
th api whoamiWho am I, which org, when does my token expire.
Config & keys
th config set KEY VALUE --environment productionConfig, secrets, and feature flags — replaces smooai-config.
th llm create-key · th llm usageMint the org’s llm.smoo.ai key; inspect spend by model and day.
th api keys create --type b2m --allowed-origin …Origin-scoped browser keys and M2M secrets.
Work tracking
th pearls create / ready / closeDependency-aware work items, Dolt-backed and git-syncable.
th jira syncBidirectional sync with the SMOODEV Jira project.
th worktree create / mergeGit worktrees in the canonical location, one command.
Models
th model login smooai-gatewayRecommended — every model resolves through one key.
th model login ollamaOr: anthropic, openai, google, kimi, kimi-code, openrouter.
th cast models · th routingList the live model roster; route each activity to a model.
Agents & extend
th agent register · th msg send --to <name>Register a handle and message other agents and sessions.
th mcp add playwright npx @playwright/mcp@latestAdd a Model Context Protocol server’s tools.
th plugin init jq --command "…"Expose any shell command as an agent tool.
th claude run "fix the flaky test"Supervise a Claude Code session through rate limits.
Service & health
th service installRun Big Smooth as a background service (launchd / systemd / Task Scheduler).
th doctorSystem health check with auto-fix.
th audit tail · th cache listTail the tool-use audit log; manage project caches.
Built in Rust on the smooth-operator engine.
Big Smooth runs on smooth-operator — our open-source, Rust-native agent engine: LLM client, tool system with hooks, agent loop, and checkpointing. Work items and memory persist in embedded Dolt, the web dashboard is React + Vite embedded in the binary, and the whole thing is served by axum on tokio. One ~10 MB binary, MIT.
Install once. Run the platform, and your own assistant.
One 10 MB binary. macOS, Linux. th config, th llm, and th apiare ready the moment it's installed. th up starts Big Smooth — your always-on AI assistant, on your machine, on the models you choose.
$ brew install SmooAI/tools/th
$ th model login smooai-gateway
$ th up
$ th code