Coyote requires the following tools to be installed on your system:

• jq
  • brew install jq
• usql (For the sql agent)
  • brew install xo/xo/usql
• docker
• uv
  • curl -LsSf https://astral.sh/uv/install.sh | sh
• iwe (iwec, for the built-in iwe MCP server that navigates large markdown knowledgebases)
  • Homebrew: brew tap iwe-org/iwe && brew trust --formula iwe-org/iwe/iwe && brew install iwe
  • Cargo: cargo install iwec
• ast-grep (for the built-in ast_grep structural code search tool, used by the explore agent)
  • Homebrew: brew install ast-grep
  • Cargo: cargo install ast-grep --locked
  • npm: npm i -g @ast-grep/cli
  • Optional: if ast-grep is not installed, the ast_grep tool reports it and agents fall back to fs_grep
• duckdb (for fast, local RAGs)
  • curl https://install.duckdb.org | sh

These tools are used to provide various functionalities within Coyote, such as document processing, JSON manipulation, and they are used within agents and tools.

If you have Cargo installed, then you can install coyote from Crates.io:

cargo install coyote-ai # Binary name is `coyote`

# If you encounter issues installing, try installing with '--locked'
cargo install --locked coyote-ai

To install Coyote from Homebrew, install the coyote tap. Then you'll be able to install coyote:

brew tap Dark-Alex-17/coyote
brew install coyote

# If you need to be more specific, use:
brew install Dark-Alex-17/coyote/coyote

To upgrade coyote using Homebrew:

brew upgrade coyote

Coyote is available as a Docker image on Docker Hub (darkalex17/coyote) for Linux amd64 and arm64. Useful for CI, ephemeral environments, or anywhere you prefer not to install it natively.

docker pull darkalex17/coyote
docker run --rm -it darkalex17/coyote

To persist your configuration across container runs, mount your existing config directory:

docker run --rm -it \
  -v ~/.config/coyote:/home/agent/.config/coyote \
  darkalex17/coyote

If you use the local vault provider and want your vault credentials available in the container, also mount the password file:

docker run --rm -it \
  -v ~/.config/coyote:/home/agent/.config/coyote \
  -v ~/.coyote_password:/home/agent/.coyote_password:ro \
  darkalex17/coyote

The image also starts a Reticulum daemon from v0.10.4 beside the main command, for the Mesh: rnsd, the background program the mesh talks to the network through, listening on the container's loopback only unless you opt into COYOTE_MESH_LAN=1. -e COYOTE_MESH_RNSD=0 leaves it off and -e COYOTE_MESH_RELAY=host:port points it at the relay your team runs. See Mesh Containers.

You can use the following command to run a bash script that downloads and installs the latest version of coyote for your OS (Linux/MacOS) and architecture (x86_64/arm64):

curl -fsSL https://raw.githubusercontent.com/Dark-Alex-17/coyote/main/install_coyote.sh | bash

You can use the following command to run a PowerShell script that downloads and installs the latest version of coyote for your OS (Windows/Linux/MacOS) and architecture (x86_64/arm64):

powershell -NoProfile -ExecutionPolicy Bypass -Command "iwr -useb https://raw.githubusercontent.com/Dark-Alex-17/coyote/main/scripts/install_coyote.ps1 | iex"

Binaries are available on the releases page for the following platforms:

The MUSL binaries are fully static and run on any distribution. That same static linking, though, means they cannot load DuckDB's extensions, so the duckdb RAG driver is unavailable in them. The GNU binary supports duckdb; it needs a recent glibc and OpenSSL 3 (libssl.so.3). The install script checks for both, verifies that the downloaded binary actually runs on your system, and falls back to MUSL when the GNU build isn't viable. So taking the script's choice is safe. coyote --update keeps whichever flavor is already installed. ARM Linux currently ships MUSL only, so duckdb is unavailable there for now.

To use a binary from the releases page on Windows, do the following:

1. Download the latest binary for your OS.
2. Use 7-Zip or TarTool to unpack the Tar file.
3. Run the executable coyote.exe!

Note: Coyote bootstraps its runtime on a dedicated 16 MiB-stack thread at startup, so it is unaffected by Windows' comparatively small default main-thread stack. If an older build ever crashed instantly on launch with a stack-overflow error (0xC00000FD), updating fixes it; no configuration is needed.

To use a binary from the releases page on Linux/MacOS, do the following:

1. Download the latest binary for your OS.
2. cd to the directory where you downloaded the binary.
3. Extract the binary with tar -C /usr/local/bin -xzf coyote-<arch>.tar.gz (Note: This may require sudo)
4. Now you can run coyote!

Coyote can update itself in place. Running:

coyote --update

downloads the latest release from GitHub for your operating system and architecture, replaces the running coyote binary, and reports the new version. Restart Coyote afterwards for the update to take effect.

To update to a specific release instead of the latest, pass a version. Either pass the bare version or the v-prefixed tag:

coyote --update v0.4.0
# or
coyote --update 0.4.0

If Coyote is already on the requested version, it reports that and makes no changes.

If Coyote was installed with Homebrew or cargo install, replacing the binary in place would leave your package manager's records out of sync with the file on disk. When coyote --update detects one of these installs it prints a warning and:

• in an interactive terminal, asks for confirmation before continuing;
• in a non-interactive context (such as a script), refuses unless --force is passed.

coyote --update --force

For Homebrew and Cargo installs the recommended way to update remains your package manager:

brew upgrade coyote                  # Homebrew
cargo install --locked coyote-ai     # Cargo

coyote --update replaces the binary at its current location. If that directory is not writable by your user (for example a coyote placed in /usr/local/bin by root), the update stops before downloading anything and asks you to re-run with elevated permissions (e.g. with sudo) or to update through your package manager.

Coyote can also be updated from within the REPL using the .update command.

You can also enable tab completions to make using Coyote easier. To do so, add the following to your shell profile:

# Bash
# (add to: `~/.bashrc`)
source <(COMPLETE=bash coyote) 

# Zsh
# (add to: `~/.zshrc`)
source <(COMPLETE=zsh coyote)

# Fish
# (add to: `~/.config/fish/config.fish`)
source <(COMPLETE=fish coyote | psub)

# Elvish
# (add to: `~/.elvish/rc.elv`)
eval (E:COMPLETE=elvish coyote | slurp)

# PowerShell
# (add to: `$PROFILE`)
$env:COMPLETE = "powershell"
coyote | Out-String | Invoke-Expression

You can integrate Coyote's Shell Assistant into your shell for enhanced command-line assistance. Add the code in the corresponding shell integration script to your shell. Then, you can invoke Coyote to convert natural language to shell commands by pressing Alt-e. For example:

$ find all markdown files<Alt-e>
# Will be converted to:
find . -name "*.md"