The Unity Pipeline package and Unity CLI: Installation guide and walkthrough

Key takeaways

• The Unity Pipeline package runs inside the Unity Editor and exposes commands through an HTTP and JSON API.
• The Unity CLI is a standalone client that lets terminals, agents, and automation scripts execute those commands.
• Built-in and custom commands support repeatable workflows, such as project setup, recompilation, testing, and runtime control.
• The same command contract can power the Unity CLI, agent workflows, and custom interfaces.

Overview

Unity CLI is free and in beta. Pair it with the Unity Pipeline package to drive your Editor from the terminal for CI, scripting, and AI agents.

The Unity Pipeline package adds a lightweight server inside your Unity Editor, allowing it to communicate directly with your terminal or other tools via standard web protocols. You can trigger commands like status checks, compilations, or test runs from the outside. Since these operations are managed asynchronously, they stay active even when the Editor reloads after a script change. This setup makes your automation consistent, predictable, and easy to script.

Components

• Unity CLI: A standalone binary that’s installed separately from the Editor, Unity CLI connects to a running Editor and drives it from the terminal. The Pipeline package requires Unity 6.0 or later.
• Unity Pipeline package: this is installed into a project (com.unity.pipeline) via the CLI. The package runs inside the Editor and auto-starts a local server when the Editor loads.
• Commands: Each command is a function in the project, tagged so Unity registers it automatically. Built-in commands cover Play mode, status, recompile, and run tests, with the option to add your own commands.
• Eval: This runs C# directly inside a live Unity instance (the Editor or a running build) for one-off actions. It executes arbitrary C# and is gated by a security token; treat it like remote code execution and keep it to local development.

Architecture

• Clients: The caller, such as a terminal, an agent, CI/CD setup or a custom UI
• Unity CLI: The primary client that turns commands into API calls; a custom UI can also speak the protocol directly
• Protocol: HTTP + JSON and the contract between the client and Unity
  • Any client that can make an HTTP request can drive Unity, in any language. By default the server binds to localhost, so clients run on the same machine as the Editor; remote callers reach it through whatever network path you expose.
• Unity Pipeline package: Installed in the project, auto-started with the Editor
  • The Pipeline package hosts two servers: the Editor server (Play mode, status, recompile, run tests, project setup) and the Runtime server (live edits in a running build via the Runtime Pipeline Manager).

Setup

Step 1: Install the Unity CLI

The Unity CLI is a standalone binary (experimental). Install it with the script or via the Package Manager, then verify. For full instructions see Unity CLI Documentation.

# macOS / Linux — install script

curl -fsSL https://public-cdn.cloud.unity3d.com/hub/prod/cli/install.sh | UNITY_CLI_CHANNEL=beta bash

# macOS / Linux — Homebrew (keeps it current)

brew install --cask unity-cli

# Windows — PowerShell install script

$env:UNITY_CLI_CHANNEL='beta'; irm https://public-cdn.cloud.unity3d.com/hub/prod/cli/install.ps1 | iex
unity --version          # verify it's on your PATH

Step 2: Sign in

Controlling an Editor requires an authenticated session:

unity auth login         # opens a browser sign-in flow

unity auth status        # confirm you're signed in

Step 3: Add the Unity Pipeline package to the project

The Unity Pipeline package runs inside the Editor and connects to the Unity CLI. If you install it from the terminal, make sure you're in the root of the Unity project you want to install into. Run unity pipeline install and by default it targets the current directory or the running Editor. You can also add com.unity.pipeline through the Package Manager. See the Unity Pipeline package docs.

unity pipeline install

Once installed, the Editor starts the server automatically. Check the new Pipeline menu to confirm.

Step 4: Connect and list the commands

With the package installed, connect to a running Editor and list what's scriptable:

unity command            # list this project's commands

The list includes the built-ins (Play mode, status, recompile, run tests) plus any custom commands. They work with any agent with no extra configuration.

Drive the Editor from the terminal

Enter Play mode, run tests, list build targets, or grab a screenshot.

unity command editor_play

unity command run_tests

unity command list_build_targets

unity command screenshot

Runs are deterministic, and the above are only a tiny slice; unity list shows the full built-in surface (scenes, prefabs, materials, animation, lighting/NavMesh bakes, builds, screenshots, packages, and more).

Custom commands

Custom commands chain a series of actions into one call from the command line. A command is a tagged function in the project. Examples:

• Run tests + notify: Run the suite and post results to the team in one call.
• Report unused assets: Scan the project and list assets with no references, to delete before a build.

A written command is deterministic and repeatable: same call, same outcome, which also makes it straightforward to hand to an agent.

Runtime control

The Runtime server drives a running build. Enable it by adding an empty GameObject, adding the Runtime Pipeline Manager component, and ticking Enable in builds. With a build running, from the terminal:

• Slow, pause, or restart time.
• Change values on the fly, and scale or move transform for a GameObject in runtime.
• Swap assets and effects at runtime.

For repeated actions, write runtime commands that ship inside the game (tweak gameplay values, override game modes). It is deterministic, repeatable, and callable by an agent.

Agents and eval

Every command is available to any agent over the CLI or its MCP mode: built-in commands, custom commands, and eval. An agent has two gears:

• Deterministic named commands for repeatable steps
• eval for one-off C# when no command exists yet

A use case could be an agent uses eval to build or change something, runs a deterministic command to exercise it, takes a screenshot, and checks the image against the prompt, iterating until it matches. eval is token-gated arbitrary C#, so scope what the agent may touch.

Security

The Unity CLI and Pipeline package are built for local development, not for shipped games. By default, everything stays on your machine; it runs only while you're developing, and running live code (eval) is gated by a per-project access key, so an agent can't execute arbitrary C# against your Editor without it. Handing the CLI to an AI agent is like giving any assistant access to your computer: it can do what you can, so decide what you let it touch, and keep the eval command to local work.

More resources

Unity CLI Documentation

Unity Pipeline package Documentation