Gide CLI Documentation

The Gide CLI is an agentic coding tool that reads your codebase, edits files and runs commands, driven by a model running on your own machine.

It is not a separate product from the GIDE editor. The CLI and the app talk to the same local server, load the same model, and share your account, folder trust and conversation history. You can start a task in the app and continue it in the terminal.

Install with a single command. Pick your platform below. The installer verifies a checksum before unpacking and puts gide on your PATH.

$ curl -fsSL https://generativeide.com/install.sh | sh

irm https://generativeide.com/install.ps1 | iex

curl -fsSL https://generativeide.com/install.cmd -o install.cmd && install.cmd && del install.cmd

Then start Gide in any project. Replace your-project with a directory on your machine:

$ cd your-project
$ gide

On first run you will sign in, approve trust for the folder, and set up a model. That is it. Continue with the Quickstart.

Build features and fix bugs

Describe what you want in plain language. Gide plans the approach, reads the files it needs, writes the code, and stops for your approval before anything touches disk.

$ gide "add pagination to the users endpoint and update the tests"

Work without sending your code anywhere

The model runs on your hardware. Your code, prompts and file contents stay on the machine, so there is no API bill, no per-token metering, and it works on a plane. Connect a cloud provider only when you explicitly want one.

Script it

Print mode runs one turn and exits with a meaningful code, so Gide composes with the rest of your shell.

$ gide -p "run the tests and fix any failures"
$ tail -200 app.log | gide -p "summarise the errors"
$ git diff main --name-only | gide -p "review these files for security issues"

Use it as a local OpenAI-compatible API

Point any OpenAI SDK at your own machine for raw model access, with none of the agent harness in the way. See Cloud and API.

Three things gate a session. The server is not one of them, because the CLI starts one for you if none is running.

A Gide account

Every session needs a signed-in account with an active subscription, checked the same way the app checks it. A valid cached session keeps working offline, so you can keep coding without a connection.

$ gide login
$ gide auth status

Folder trust

Gide reads, edits and runs commands inside the folder you open, and nowhere else. The first run in a directory shows what it is about to trust and asks. Trust covers the whole subtree and is shared with the app.

$ gide trust
$ gide trust add
$ gide trust list

Sensitive locations such as your home directory or a filesystem root need the folder name typed to confirm, and are never granted automatically. A non-interactive run will not prompt; it exits so a script cannot silently gain access.

A model, set up on first run

You do not need a model in advance. The first interactive run offers to download the recommended one or connect a cloud provider with your own key.

Versions are installed side by side with a current link pointing at the active one, so an update can be rolled back.

• Files land in ~/.gide/cli/versions/ on macOS and Linux, and under %USERPROFILE%\.gide\cli on Windows.
• The command is ~/.local/bin/gide, or %LOCALAPPDATA%\gide\bin\gide.cmd on Windows.
• Windows adds that directory to your PATH automatically. On macOS and Linux the installer prints the line to add if it is not already there.
• Model weights are never part of the download. They arrive on first run.

The Windows download is around 800 MB against roughly 100 MB on macOS. Windows ships every GPU backend in one package, CUDA for NVIDIA, Vulkan for AMD and Intel, plus a CPU fallback, and bundles the CUDA runtime so you do not need the toolkit installed. macOS needs only a small Metal library.

Updating

The CLI checks for a new version once a day and mentions it in the banner. Updating is explicit.

$ gide update

Removing it

There is no uninstall command. Delete the shim and the install directory.

$ rm ~/.local/bin/gide && rm -rf ~/.gide/cli

Open a project and describe what you want. Gide explores the codebase, proposes edits, and stops for approval before writing anything or running any command.

1. 1

   Open a project

   Run gide in any directory with code in it.

2. 2

   Approve the folder

   Confirm that Gide may work in this directory. It is remembered, and shared with the app.

3. 3

   Set up a model

   Download the recommended model, or connect your own API key. This happens once.

4. 4

   Describe a task

   Type it in plain language. Gide reads what it needs and proposes changes.

5. 5

   Approve the change

   Review the diff and accept or reject. Nothing is written until you decide.

Here are real recorded sessions, played back at their original pace:

Global flags

Commands

Exit codes

Print mode is meant to be scripted, so failures are distinguishable rather than all being 1.

Inside a session, type / to open the command menu with autocomplete. There are thirteen commands. Several also take arguments, so you can skip the interactive picker when you already know what you want.

Session

Models

Account and providers

Usage

Approving changes

Nothing is written and no command runs until you say so. A write gate shows the exact diff; a command gate shows the command and where it would run. Try it:

Allowing all lifts the gate for the rest of the session only. Pressing escape always rejects.

Keyboard

The @ picker walks your project honouring its own .gitignore, and ranks matches by filename before path. While a turn is running you can keep typing. Enter queues the prompt and it sends when the turn finishes.

Resuming work

$ gide --continue
$ gide --resume

History is stored per project and written by whichever client ran the turn, so a conversation started in the app can be resumed in the terminal.

Models are shared with the app and stored once in ~/.gide/models. Downloads are resumable and checksum verified.

$ gide models
$ gide models pull
$ gide models select qwen

Using your own GGUF

Any GGUF file works. Point Gide at one and the server reads the file's own metadata, its architecture, chat template and tool-call format, to derive a behavior profile. The model does not have to be one Gide already knows about.

$ gide models select ~/models/my-model.gguf
$ gide models profile

The profile is written to a JSON file you can edit if a guess is wrong. Inside a session, /model offers the same thing through a file picker.

Tuning

/temperature and /layers open interactive scales. Temperature applies from the next message, while changing GPU layers reloads the model in place. Run gide hardware to see what your machine supports.

Bring your own key

If you would rather use a frontier model for a task, connect a provider with your own key. Prompts then go to that provider instead of staying local, and the CLI says so when you connect.

$ gide connect anthropic
$ gide disconnect

OpenAI-compatible API

The local server exposes an OpenAI-compatible endpoint, so any tool or SDK that speaks that protocol can use your local model. This is raw model access with your system prompt and your message history, and none of Gide's agent harness or memory.

$ gide apikey create my-tool

The key is shown once and stored only as a hash. Revoking takes effect immediately.

Streaming is supported, and reasoning models split their thinking into a separate field. Tool calling, multiple completions, response formats and logprobs are not supported, and each returns a clear error rather than failing oddly. A busy model returns 429 with a retry header, and the endpoint is disabled while Private Cloud is connected. Usage is metered per key and appears in gide usage.

Private Cloud

Enterprise plans can run against a hosted model on Gide's key, for machines that cannot run one locally.

Environment variables

Files

Everything lives under ~/.gide and is shared with the app.

Start here. It checks every part of the local setup and names what is wrong.

$ gide doctor