Skip to main content

Installation

Anyy ships as a single native Go binary named anyy. There are two supported ways to get it: install a prebuilt release artifact (the recommended path), or build from source. This page covers both, plus how to verify the result.

Installing only places the binary and prepares Anyy's home directory. To run Anyy as a long-lived background service, see Running Resident. For first-run configuration (provider, model, channels), see Setup. To upgrade an existing install, see Updating.

Quick Install​

Release artifact install​

The canonical one-line installer downloads a checksum-verified release for your OS and architecture and installs it into Anyy's resident layout:

curl -fsSL https://anyy.ai/install.sh | sh
warning

This command pipes a shell script straight into sh. Before running it on a machine you care about, read what it does: it detects your OS/architecture, resolves the latest release, downloads the archive and its CHECKSUMS.sha256, verifies the SHA-256 before extracting, and installs the binary under your home directory. It does not require root, does not edit your shell startup files, and does not install or start any background service. You can inspect the script first by opening https://anyy.ai/install.sh in a browser.

What the installer does, in order:

  1. Detects your OS (darwin or linux) and architecture (amd64 or arm64).
  2. Resolves the install home (ANYY_HOME): your explicit value if set, otherwise /root/.anyy when running as root, or $HOME/.anyy otherwise.
  3. Resolves the latest stable version from https://anyy.ai/releases/latest.
  4. Runs a preflight: required commands (curl, tar, gzip, awk, …), available disk space, and stale temporary files.
  5. Downloads anyy_<version>_<os>_<arch>.tar.gz and CHECKSUMS.sha256.
  6. Verifies the SHA-256 checksum before extracting.
  7. Installs into the resident release layout and atomically switches the current release.
  8. Records an install marker at .install/source.json.
  9. Creates a usable command entrypoint when it can do so safely (see Install verification).

You will see phase output like this, with a curl progress bar for the archive:

Downloading Anyy v0.1.57 (darwin/arm64)...
######################################################################## 100.0%
Verifying checksum...
Installing to /Users/you/.anyy...
Installed Anyy v0.1.57.
Command: anyy

Install options​

The installer reads a few environment variables:

VariablePurpose
ANYY_HOMEOverride the install home directory.
VERSIONInstall a specific version (e.g. v0.1.57) instead of latest.
ANYY_RELEASE_BASE_URLPoint at an alternate release source.
ANYY_INSTALL_COMPACTSet to 1 to allow pruning old rollback history on low-disk hosts.

On a host that is tight on disk, use compact mode. It may prune inactive releases (never the active one) and only prunes the previous rollback target when home storage would otherwise be insufficient:

curl -fsSL https://anyy.ai/install.sh | ANYY_INSTALL_COMPACT=1 sh

To install a pinned version instead of latest:

curl -fsSL https://anyy.ai/install.sh | VERSION=v0.1.57 sh

Source install​

If you have a Go toolchain, you can build the binary yourself from the repository. Anyy requires Go 1.26 (see go.mod). The Go module path is github.com/mai8304/anyy.

The repository ships a Makefile target that builds with the correct version ldflags injected:

make build

This produces dist/anyy. Under the hood it runs:

go build -ldflags "..." -o dist/anyy ./cmd/anyy

The -ldflags stamp the version, commit, build date, and channel into the binary so anyy --version reports accurate build metadata. A plain go build ./cmd/anyy also works but reports dev as the version.

A source build is not placed into Anyy's resident layout, so anyy update will not self-replace it. To run a source build as a managed resident install, hand the built binary to the install script (see Manual And Developer Install).

Install verification​

After installing, confirm the binary is on your PATH and reports the expected build:

anyy --version
Anyy (anyy) version v0.1.57 channel stable commit 8627a748340f built 2026-06-15T08:03:45Z

Check that the command resolves to the resident install:

command -v anyy

For a non-root install this is typically ~/.local/bin/anyy, a symlink into ~/.anyy/bin/anyy.

If anyy is not found, the installer prints PATH-repair guidance rather than editing your shell startup files. For a normal user install, add ~/.local/bin to your PATH; for a root install, the entrypoint goes into the first writable directory among /usr/local/bin, /opt/homebrew/bin, or /usr/bin.

For a deeper health check of the configured runtime, run:

anyy doctor

Prerequisites​

The release installer is POSIX sh compatible and works on macOS and Linux (including small BusyBox-style environments). It needs these commands on PATH:

  • curl — download the release and checksums
  • tar and gzip — extract the archive
  • awk, sed, mktemp, readlink
  • sha256sum or shasum — verify the checksum

Supported platforms are darwin/linux on amd64/arm64. Building from source additionally requires Go 1.26+.

Home Directory Layout​

Anyy keeps its state under a home directory — ~/.anyy for a normal-user install, /root/.anyy when running as root. Override it with the --home flag or the ANYY_HOME environment variable (/root/.anyy is the built-in fallback used when no home is otherwise resolved). The installer creates the directory with 0700 permissions and lays out a versioned release structure:

~/.anyy/
├── current -> releases/v0.1.57     # symlink to the active release
├── releases/
│   └── v0.1.57/anyy           # the installed binary for this version
├── bin/
│   └── anyy -> ../current/anyy
├── .install/
│   ├── source.json                 # install source marker
│   └── previous                    # rollback target marker
├── secrets/        skills/        memory/
├── sessions/       logs/          cache/
├── workspace/      backups/       checkpoints/
└── config.yaml                     # created during setup

Activation is atomic: a new release is staged under releases/<version>, then current is switched with a temp-symlink-and-rename. The previous release is retained so anyy update can roll back. The .install/source.json marker records how Anyy was installed, for example:

{
  "source": "resident",
  "method": "curl",
  "channel": "stable",
  "version": "v0.1.57",
  "artifact_digest": "sha256:...",
  "installed_at": "2026-05-29T00:00:00Z",
  "managed": false
}

This marker is advisory, not a security boundary. It tells anyy update whether the install is a self-updatable resident install or an externally managed one (npm, brew, docker), a source build, or unknown.

Manual And Developer Install​

The install script also accepts a path to a local anyy binary. This installs your own build into the resident layout (recording method local, channel dev) so it benefits from atomic activation and rollback:

VERSION=dev scripts/install.sh /path/to/anyy

A typical developer loop is therefore:

make build
VERSION=dev scripts/install.sh dist/anyy

This is the bridge between a source build and a managed resident install. Use it when you want to run a locally built binary as the active resident release.

Service User Install​

To run Anyy as a root-owned resident under /root/.anyy (the host layout), run the installer as root or set the home explicitly:

curl -fsSL https://anyy.ai/install.sh | ANYY_HOME=/root/.anyy sh

When running as root, the installer additionally links a global command into the first writable directory among /usr/local/bin, /opt/homebrew/bin, or /usr/bin.

Installing does not install or start a background service — that step is explicit. For turning a resident install into a long-running service, see Running Resident.

Troubleshooting​

anyy: command not found after install. The installer never edits shell startup files. Add the entrypoint directory to your PATH — ~/.local/bin for a user install — then re-open your shell. Run command -v anyy to confirm it resolves into ~/.anyy/bin/anyy.

A different anyy is found on PATH. If command -v anyy points outside ~/.anyy, an earlier entry on your PATH is shadowing the resident install. Reorder your PATH so the resident entrypoint wins.

Preflight fails with "not enough space". Free space in your temp directory or home, or retry with ANYY_INSTALL_COMPACT=1 to prune old rollback history.

"another Anyy install or update is already running". A per-home update lock at .install/update.lock is held by a concurrent install or update. Wait for it to finish, then retry.

Checksum mismatch. The download did not match the published CHECKSUMS.sha256 (a partial download, a stale cache, or the wrong asset). Re-run the installer; it re-downloads and re-verifies before extracting.

anyy update says the install is not self-updatable. Your .install/source.json marks the install as managed, source, or unknown. Only resident installs self-update. See Updating for the guidance Anyy prints per source.