The Cursor command line is a separate surface with its own installation, its own updates and its own version. The official way is an install script: on macOS, Linux and the Windows subsystem it installs with one line, and on Windows there is a separate variant through PowerShell. The first thing to do after installing is to ask for the version: that is both a health check and a record of exactly what runs on your machine. It is separate in meaning too: the editor may never be opened at all while the agent in the terminal remains a working tool.
The naive expectation is that installation is the same everywhere and that afterwards the command simply exists. In practice the most frequent first-run problem is not installation but paths: the script places the command into a user directory the shell does not know about. The symptom looks like a missing program, the cause is in the path variable. What adds to the confusion is that the current shell session reads the variable once at start: editing the profile without restarting changes nothing, and the person concludes that the edit did not help.
The command line usually updates itself, but there is also an explicit update command. The difference matters for automation: where reproducibility is required you cannot rely on automatic updates - tomorrow's run may execute a different version with different behavior. In such places the version is pinned explicitly and updated deliberately, as a separate step, with verification.
It helps to see the install commands for all platforms and the version check together once. They are given below. A practical habit worth adopting immediately: write the version into bug reports and automation logs. Half of the unclear discrepancies between machines are explained precisely by different versions, and one line in a log settles the question before it turns into an hour of discussion.
Diagnosing a path problem goes step by step and takes a couple of minutes. First you find out where the command physically lies, then which file the shell finds by that name. A mismatch between those two answers is the nastiest variant: there are several copies, one came with the install script and another from a package manager, and the one that runs is not the one you updated. The report then carries the version you checked by hand while a different one does the work. So the version is checked with the same invocation that does the work rather than with a neighbouring one.
Installation by piping from the network into a shell deserves a separate word. That is the official method, but in essence it remains downloading and executing a remote script with your rights. In ordinary work that is acceptable; in a regulated environment it is better to download the artifact, review it, put it into an internal distribution channel and install from there. The difference is not paranoia but who answers for the contents of the executable.
Reproducibility discipline matters especially for the command line, because that is what goes into scripts and continuous integration. There nobody can fix anything by hand: a run is either deterministic or it is not. So automation pins the version, sets explicit flags and does not rely on machine state that came about on its own.
The sign by which a version change is recognized in real work is simple: yesterday the run was green, today it is red, and nothing changed in the repository. The first thing compared in that situation is not the code but the tool versions on the two runs; if the version is not written into the log there is nothing to compare and guesswork begins. Hence the limit of applicability for automatic updates: on a personal machine they are appropriate, because the cost of a mistake is five minutes of your time, while in shared automation they are not, because the cost is someone else's broken run at an inconvenient hour.
The engineering conclusion is simple: treat the command line as a project dependency. It has a version, an update channel and an owner. If that is written down, diagnosis turns into reading a log; if not, every discrepancy has to be worked out anew by comparing machines.
The typical failures are predictable. Failing to find the command after installation and looking for a problem in the product instead of the path variable. Relying on automatic updates where reproducibility is needed. Installing by pipe from the network in a regulated environment without agreeing the channel. And not writing the version into logs, paying for it with hours of diagnosis later.
# Windows PowerShell
irm 'https://cursor.com/install?win32=true' | iex
agent --version
# Explicit update: agent update; automation pins the version instead of updating itself# macOS, Linux and the Windows subsystem
curl https://cursor.com/install -fsS | bash
agent --version
# If the command is not found, the directory is not in PATH - the product is not broken