It is designed to include a number of useful agents, roles, macros, and more so users can get up and running with Coyote in as little time as possible. You can also install entire bundles of agents, roles, macros, tools, and MCP servers from any git repository. See Sharing Configurations for more information.

Coming from AIChat? Follow the migration guide to get started.

Quick Links

AIChat Migration Guide: Coming from AIChat? Follow the migration guide to get started.
Installation: Install Coyote
Getting Started: Get started with Coyote by doing first-run setup steps.
Sharing Configurations: Install bundles of agents, roles, macros, tools, and MCP servers from any git repo, and share your own.
REPL: Interactive Read-Eval-Print Loop for conversational interactions with LLMs and Coyote.
- Custom REPL Prompt: Customize the REPL prompt to provide useful contextual information.
Vault: Securely store and manage sensitive information such as API keys and credentials.
Sandboxes: Launch Coyote inside an isolated Docker Sandbox with one command. Host config and vault credentials are projected in automatically; everything else is delegated to the sbx CLI.
Shell Integrations: Seamlessly integrate Coyote with your shell environment for enhanced command-line assistance.
Function Calling: Leverage function calling capabilities to extend Coyote's functionality with custom tools
- Creating Custom Tools: You can create your own custom tools to enhance Coyote's capabilities.
First-Class MCP Server Support: Easily connect and interact with MCP servers for advanced functionality.
Macros: Automate repetitive tasks and workflows with Coyote "scripts" (macros).
RAG: Retrieval-Augmented Generation for enhanced information retrieval and generation.
Sessions: Manage and persist conversational contexts and settings across multiple interactions.
Memory: Persistent file-based memory that survives across sessions. Bootstrap with coyote --init-memory [global|workspace].
Roles: Customize model behavior for specific tasks or domains.
Skills: Modular knowledge or capability packs the LLM can load and unload mid-conversation. Multiple skills compose; instructions stack, tools and MCPs union.
Agents: Leverage AI agents to perform complex tasks and workflows, including sub-agent spawning, teammate messaging, and user interaction tools.
- Graph Agents: Define an agent as a declarative, YAML-driven workflow. A directed graph of typed nodes (LLM calls, scripts, approvals, user input, RAG retrieval, sub-agent spawns).
Todo System: Built-in task tracking for improved LLM reliability with smaller models.
Environment Variables: Override and customize your Coyote configuration at runtime with environment variables.
Client Configurations: Configuration instructions for various LLM providers.
- Authentication (API Key & OAuth): Authenticate with API keys or OAuth for subscription-based access.
- Patching API Requests: Learn how to patch API requests for advanced customization.
Custom Themes: Change the look and feel of Coyote to your preferences with custom themes.
History: A history of how Coyote came to be.

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

These tools are used to provide various functionalities within Coyote, such as document processing, JSON manipulation, etc., 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

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

Windows Instructions

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

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

Linux/MacOS Instructions

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

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

Updating

Coyote can update itself in place to the latest GitHub release. Run coyote --update for the newest release, or coyote --update v0.4.0 for a specific version:

coyote --update
coyote --update v0.4.0

The same is available from within the REPL via .update and .update v0.4.0.

If Coyote was installed with a package manager, prefer that package manager so its records stay in sync with the binary on disk; i.e. brew upgrade coyote for Homebrew, or cargo install --locked coyote-ai for Cargo.

When Coyote detects a package-manager install it prints a warning and asks for confirmation. In a non-interactive shell (no TTY), pass --force to update anyway:

coyote --update --force

Getting Started

After installation, you can generate the configuration files and directories by simply running:

coyote --info

Then, you need to set up the Coyote vault by creating a vault password file. Coyote will do this for you automatically and guide you through the process when you first attempt to access the vault. So, to get started, you can run:

coyote --list-secrets

Authentication

Each client in your configuration needs authentication (with a few exceptions; e.g. ollama). Most clients use an API key (set via api_key in the config or through the vault). For providers that support OAuth (e.g. Claude Pro/Max subscribers, Google Gemini), you can authenticate with your existing subscription instead:

# In your config.yaml
clients:
  - type: claude
    name: my-claude-oauth
    auth: oauth # Indicate you want to authenticate with OAuth instead of an API key

coyote --authenticate my-claude-oauth
# Or via the REPL: .authenticate

For full details, see the authentication documentation.

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"

Configuration

The location of the global Coyote configuration varies between systems, so you can use the following command to find your config.yaml file:

coyote --info | grep 'config_file' | awk '{print $2}'

The configuration file consists of a number of settings. To see a full example configuration file with every setting defined, refer to the example configuration file.

Default LLM

The following settings are available to configure the default LLM that is used when you start Coyote, and its hyperparameters:

Setting	Description
`model`	The default LLM to use when no model is provided
`temperature`	The default `temperature` parameter for all models (0,1); Used unless explicitly overridden
`top_p`	The default `top_p` hyperparameter value to use for all models, with a range of (0,1) (or (0,2) for some models); Used unless explicitly overridden

CLI Behavior

You can use the following settings to modify the behavior of Coyote:

Setting	Default Value	Description
`stream`	`true`	Controls whether to use stream-style APIs when querying for completions from LLM providers
`save`	`true`	Controls whether to save each query/response to every model to `messages.md` for posterity; Useful for debugging
`keybindings`	`emacs`	Specifies which keybinding schema to use; can either be `emacs` or `vi`
`editor`	`null`	What text editor Coyote should use to edit the input buffer or session (e.g. `vim`, `emacs`, `nano`, `hx`); Defaults to `$EDITOR`
`wrap`	`no`	Controls whether text is wrapped (can be `no`, `auto`, or some `<max_width>`
`wrap_code`	`false`	Enables or disables the wrapping of code blocks

Preludes

Preludes let you define the default behavior for the different operating modes of Coyote. The available settings are shown below:

Setting	Description
`repl_prelude`	This setting lets you specify a default `session` or `role` to use when starting Coyote in REPL mode. Values can be `role:<name>` to define a role `session:<name>` to define a session `<session>:<role>` to define both a session and a role to use
`cmd_prelude`	This setting lets you specify a default `session` or `role` to use when running one-off queries in Coyote via the CLI. Values can be `role:<name>` to define a role `session:<name>` to define a session `<session>:<role>` to define both a session and a role to use
`agent_session`	This setting is used to specify a default session that all agents should start into, unless otherwise specified in the agent configuration. (e.g. `temp`, `default`)

Appearance

The appearance of Coyote can be modified using the following settings:

Setting	Default Value	Description
`highlight`	`true`	This setting enables or disables syntax highlighting
`light_theme`	`false`	This setting toggles light mode in Coyote

Miscellaneous Settings

Setting	Default Value	Description
`user_agent`	`null`	The name of the `User-Agent` that should be passed in the `User-Agent` header on all requests to model providers
`save_shell_history`	`true`	Enables or disables REPL command history

History

Coyote began as a fork of AIChat CLI and has since evolved into an independent project.

See CREDITS.md for full attribution and background.

Creator

Alex Clarke

README.md

Coyote: All-in-one, batteries-included LLM CLI Tool