Dark-Alex-17/coyote
1
0
Fork 0
Code Issues Pull Requests Actions 2 Packages Projects Releases Wiki Activity
Page: Installation
Pages
AIChat Migration Agents Background Jobs Bash Prompt Helpers Bundles Clients Custom Bash Tools Custom Tools Environment Variables Getting Started Graph Agents Home Installation MCP Servers Macros Memory Model Sync Patches RAG REPL Prompt REPL Roles Sandboxes Sessions Shell Integrations Skills TODO System Themes Tools Unattended Mode Vault Workspace Instructions
Clone
9
Installation
Alex Clarke edited this page 2026-08-28 22:33:30 -06:00
Table of Contents

Prerequisites

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.

Install

Cargo

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

Homebrew (Mac/Linux)

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

Docker

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

Scripts

Linux/MacOS (bash)

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

Windows/Linux/MacOS (PowerShell)

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"

Manual

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

Platform Architecture(s)
macOS x86_64, arm64
Linux GNU/MUSL x86_64, aarch64
Windows x86_64, aarch64

Linux: GNU or MUSL?

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.

Windows Instructions

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!

Linux/MacOS Instructions

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!

Updating 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.

Package-manager installs

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

Permissions

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.

Tab-Completions

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

Shell Integration

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"

Start Here

Using Coyote

Model Providers

Tools & Function Calling

Agents

Knowledge & Automation

Configuration