# The tallos CLI and bundled skills: let your agents drive Tallos

> The `tallos` CLI is the command-line interface to a running Tallos app. Agents and scripts use it to create worktrees, read and send input to terminals, automate the built-in browser, schedule automations and coordinate other agents. Tallos ships skills that teach agents these commands and installs them automatically, offline, into the coding agents it detects on first launch.

- Canonical: https://runtallos.com/features/tallos-cli-and-skills
- Português: https://runtallos.com/pt/recursos/cli-e-skills.md
- Updated: 2026-09-29
- Section: Features

## Key facts

- One `tallos` command on macOS and Windows
- Worktrees, terminals, files, browser, automations, orchestration
- 7 bundled skills, installed on first launch without a download
- `--json` output on every command for agents
- Version-matched guides with `tallos skills get`

## What is the tallos CLI?

The **`tallos` CLI** is a command-line tool that controls a running Tallos app from any shell. A person can use it in scripts; more often, an agent uses it. Claude Code in one workspace can create a second workspace, start Codex there with a prompt, wait for it to finish and read its output, without you clicking anything.

It ships with the desktop app. Tallos registers the `tallos` command on your `PATH` from Settings, and terminals opened by Tallos already know where to find it. Most commands accept `--json` for machine-readable output, and `tallos agent-context` prints the full command schema so an agent can discover what is available instead of guessing flags.

> **Needs a running app** — Most commands talk to the running Tallos app. If it is closed, `tallos open` launches it and waits until it is ready; `tallos status` shows whether it is reachable.

## What can agents do with the tallos command?

| Group | What agents do with it | Example |
| --- | --- | --- |
| `worktree` | Create, list, inspect, annotate and remove isolated workspaces | `tallos worktree create --name fix-login --agent codex --prompt "..."` |
| `terminal` | Create, split, read, wait on and send input to terminals | `tallos terminal wait --for tui-idle --timeout-ms 30000` |
| `file` | Open files, diffs or every changed file in the editor | `tallos file open-changed --mode diff` |
| Browser | Navigate, snapshot, click, fill, screenshot, emulate devices | `tallos snapshot` then `tallos click --element e3` |
| `automations` | Create, edit, run and inspect scheduled agent runs | `tallos automations run <id>` |
| `orchestration` | Tasks, supervised workers, messages and decision gates across agents | `tallos orchestration worker-start --task <id> --agent claude` |
| `linear` | Read, search, comment on and create Linear issues | `tallos linear issue ENG-142 --comments` |
| `emulator` | Tap, type and inspect an iOS Simulator or Android device | `tallos emulator tap 0.5 0.8` |
| `computer` | Operate native app windows through the accessibility tree | `tallos computer get-app-state --app <app>` |
| `search` | Full-text search across past agent sessions | `tallos search "stripe webhook"` |

_Main command groups_

The same surface powers [squads](https://runtallos.com/features/squads): the leader agent coordinates members through orchestration, asks you questions with `tallos squad ask` and hands in its result with `tallos squad report`.

## What does an agent handoff look like?

Here is a typical handoff an agent can run on its own: open a new workspace for a sub-task, start another agent in it, wait, then read what happened.

```bash
tallos worktree create --name billing-audit --agent codex \
  --prompt "Audit the billing settings page on mobile" --json
tallos terminal list --worktree name:billing-audit --json
tallos terminal wait --terminal <handle> --for tui-idle --timeout-ms 900000 --json
tallos terminal read --terminal <handle> --limit 200 --json
```

Each workspace is its own branch and working copy, so the second agent never touches the first one's files. That is the basis of [multi-agent development](https://runtallos.com/multi-agent-development).

## What are Tallos skills?

A **skill** is a folder with a `SKILL.md` file that tells a coding agent when to use a tool and how. Tallos bundles its skills inside the app. On first launch it installs them into the coding agents it detects on your computer: offline, with no `npx`, no repository download and no setup step for you.

| Skill | What it teaches the agent |
| --- | --- |
| `tallos-cli` | Worktrees, terminals, repos, automations, handoffs and the built-in browser through `tallos` |
| `orchestration` | Supervising other agents: tasks, dispatch, messages, blocking questions, decision gates |
| `tallos-linear` | Working from a Linear ticket: read, move state, comment, attach the PR, create follow-ups |
| `tallos-emulator` | Driving an iOS Simulator on macOS from the emulator pane |
| `tallos-emulator-android` | Driving an Android emulator or device over adb on macOS or Windows |
| `tallos-per-workspace-env` | Setting up a disposable environment (sandbox, VM, SSH host or container) per workspace |
| `computer-use` | Operating visible native app windows when no CLI or API can do the job |

_Skills bundled with Tallos_

- **Always current.** Later launches repair skills that are missing or outdated, so they match your Tallos version.
- **Your skills are safe.** Tallos only manages its own skills; skills you installed from other sources are never touched.
- **Reinstall anytime.** Settings → Agent skills has **Install now** and **Reinstall**. If no agent is detected yet, [connect your agents](https://runtallos.com/learn/connect-your-agents) first.

## Give your agents the keys

> Install Tallos, open your agents, and they already know how to create workspaces and drive the browser. → https://runtallos.com/signup

## Which agents get the skills?

Tallos places skills for the agents it detects that read a skills folder, including [Claude Code](https://runtallos.com/integrations/claude-code), [Codex](https://runtallos.com/integrations/codex), [Gemini CLI](https://runtallos.com/integrations/gemini-cli) and Grok, among others. Each agent gets the skills in the location it already reads, so there is nothing to configure.

Installed skills are short on purpose. They tell the agent when to reach for Tallos and then load the full guide from the CLI with `tallos skills get <name>`. The guide comes from the same build as the app, so documented flags never drift from what the command accepts.

```bash
tallos skills list
tallos skills get tallos-cli
tallos skills get orchestration --full
```

## Why a CLI and skills instead of only an MCP server?

Every coding agent can already run shell commands, so a CLI works in any of them with no extra protocol support. Skills add the "when" and "how" on top. Agents that support MCP keep their MCP servers, and Tallos lets you inspect the MCP configs each repo defines; the two approaches coexist.

**Agent without the tallos CLI**
- Runs raw `git worktree` and ad hoc shells
- Cannot see or wait on other agents' terminals
- Describes UI bugs from screenshots you paste

**Agent with the tallos CLI and skills**
- Creates Tallos-managed workspaces you can see in the sidebar
- Reads, waits on and messages other agents' terminals
- Drives the built-in browser and checks its own work

## Frequently asked questions

### What is the tallos command?

`tallos` is the command-line interface that ships with the Tallos desktop app. It lets agents and scripts control a running Tallos: worktrees, terminals, files, the built-in browser, automations and orchestration.

### Do I need to install Tallos skills manually?

No. Tallos installs its bundled skills automatically on first launch into the coding agents it detects, without downloading anything. You can reinstall them from Settings → Agent skills.

### Which skills come with Tallos?

`tallos-cli`, `orchestration`, `tallos-linear`, `tallos-emulator`, `tallos-emulator-android`, `tallos-per-workspace-env` and `computer-use`.

### Will Tallos overwrite skills I wrote myself?

No. Tallos only installs and repairs its own bundled skills. Skills from other sources are left untouched.

### Can Claude Code open a new worktree and start Codex in it?

Yes. With the `tallos-cli` skill, Claude Code can run `tallos worktree create --agent codex --prompt "..."`, then wait on and read that terminal with `tallos terminal wait` and `tallos terminal read`.

### Does the tallos CLI work on Windows?

Yes. The `tallos` command is registered on macOS and Windows, and terminals opened by Tallos can find it automatically.

### How does an agent learn the exact flags?

It runs `tallos skills get <name>` for the version-matched guide, or `tallos agent-context` for the machine-readable command schema, instead of guessing from memory.

---

**Run your agents in parallel with Tallos** — Claude Code, Codex, Gemini and 30+ agents — each in its own workspace, with squads, chat, terminals and review in one app. Uses the subscriptions you already have.

https://runtallos.com/signup (macOS 13+ · Windows 10+)