dalo 1.2.0

AI agent skill manager: version, review, and sync skills through your agent.
Documentation

Dalo

Your team's agent skills, versioned like code.

Powered by Sebastian Software Crates.io npm CI License: MIT OR Apache-2.0 MSRV

For engineers and team leads who run Claude Code, Codex, or another agent across several people and machines: keep every skill in Git, resolve one approved set, and link it into the folders your agents already read. Your agents keep reading the folders they understand. Dalo handles what is behind them — sources, priorities, approvals, conflicts, drift, and safe synchronization.

Visit dalo.sh · Watch the 15-second demo · Get started

Install

Ask your local coding agent: “Install the Dalo skill manager.” The agent setup guide covers the binary, the bundled Dalo assistant, and verification. No preinstalled Dalo skill is needed. Use Dalo through your agent.

Dalo runs on macOS and Linux:

# macOS with Homebrew
brew install sebastian-software/tap/dalo

# macOS or Linux with the hosted installer
curl -fsSL https://dalo.sh/install.sh | sh

# Node.js 20 or newer, without a global install
npx getdalo --version

Cargo, Cargo Binstall, mise, Nix, manual archives, and checksum and provenance verification are covered in Installation further down.

Five minutes to a synced skill set

1. Create the store. It holds sources, locks, approvals, and audits. Agent folders stay output targets.

dalo init

2. See which agents are installed. Detection is read-only and names the default skill directory of every supported agent.

dalo target detect

3. Link the agents you use. Repeat for every agent; generic takes an explicit path for anything folder-based.

dalo target link codex
dalo target link claude
dalo target link cursor

4. Add your team's skill repository. Dalo clones it into the store and runs a deterministic security preflight on every skill it finds.

dalo source add company git@github.com:acme/agent-skills.git

5. Sync. One command resolves the approved set and links it into every configured target.

dalo sync
applied  create     target[codex]:/incident-review -> store:/sources/company/checkout/skills/incident-review
applied  create     target[codex]:/release-notes -> store:/sources/company/checkout/skills/release-notes
synced: 2 skills across 1 target (2 created)
security preflight: deterministic checks only

6. Check what an agent is actually using. status lists managed, unmanaged, shadowed, blocked, and pending skills; dalo doctor adds a focused health check.

dalo status

The quickstart is also available as a short MP4 video.

When something is off

Recover without googling. Every blocking state names the exact next command — did-you-mean suggestions, known-ID lists, and a concrete fix from sync, status, and doctor.

A catalog skill is a good example. Selecting it does not trust it, so the next sync links what is approved and reports the rest instead of guessing:

dalo source add-catalog sebastian https://github.com/sebastian-software/skills.sebastian-software.com.git
dalo source select sebastian effective-web
dalo sync
synced: 2 skills across 1 target (2 unchanged)
pending approval: sebastian:effective-web (run: dalo approve skill sebastian:effective-web)
security preflight: deterministic checks only

Review the exact skill, approve it, and sync again:

dalo audit sebastian:effective-web
dalo approve skill sebastian:effective-web
dalo sync

Conflicts, drift, dirty checkouts, and blocked audits behave the same way. The troubleshooting guide lists every resolver, doctor, and security finding with the command that clears it.

Safe by design

 team repositories    public catalogs    local experiments
         \                  |                  /
          +-----------------+-----------------+
                            |
                            v
                     ~/.dalo store
             sources · locks · trust · audits
                            |
                            v
              preflight · agent review
                            |
                            v
                 deterministic resolution
                            |
             +--------------+--------------+
             v              v              v
           Codex       Claude Code     other agents

The store is the source of truth; agent folders are output targets. Git repositories stay clean inputs, local work has a private home, and agent directories contain only the resolved links Dalo owns:

  • unmanaged files and real directories are never overwritten during sync
  • Dalo removes or repairs only the links and managed blocks it owns
  • dirty team checkouts block refresh instead of losing local changes
  • catalog skills require an explicit selection and approval
  • source additions and catalog selections show deterministic security preflights
  • sync blocks high and critical findings from deterministic checks and compatible cached reviews before a skill reaches an agent folder
  • optional sandboxed reviews can reuse an installed Codex, Claude, or OpenCode CLI
  • sync does not start an agent reviewer, and a passing preflight is not a safety guarantee
  • newly active skills are not silently trusted during non-interactive sync
  • --dry-run shows planned changes without writing them
  • conflicts stay visible in status until you resolve or intentionally keep them

The core rule is simple:

Dalo may manage what it owns. It does not take ownership by surprise.

For the full picture — trust boundaries, what the preflight catches, and the list of things Dalo deliberately does not protect against — read the security overview.

What else Dalo does

  • Public catalogs. Add a catalog, inspect it, and select only the skills you want; selections are pinned and source refresh reports upstream movement instead of silently advancing the lock. Getting started
  • Team manifests. A team repository can pin external catalogs to exact commits and define the subset every member resolves, while approval stays personal. Team repository guide
  • Instruction packs. Share conventions that are not skills as managed blocks inside agent instruction files; everything else in the file stays yours. Agent integration
  • Autosync. Install a safe recurring sync on launchd or a systemd user timer that never waits on a prompt and never grants approvals. Command reference
  • Portable plugins. Group skills, agents, and instructions in an inert package, with narrowly typed tools and hooks behind separate exact approvals. Plugins, tools, and hooks
  • Adopt. Copy a skill an agent wrote in its own folder into your private local source, and replace the original with a managed link only if you ask. Command reference
  • Doctor. dalo doctor turns store, target, lock, and approval health into findings with a recovery command each. Troubleshooting and FAQ

Agent support

Agent Default skill directory
Codex ~/.agents/skills
Claude Code ~/.claude/skills
Cursor ~/.cursor/skills
OpenClaw ~/.agents/skills
Hermes ~/.hermes/skills
OpenCode ~/.config/opencode/skills
Any folder-based agent user-provided path

Every built-in target names the agent release it was verified against in the agent support matrix. dalo target link cursor uses Cursor's default skill directory; pass a project path to target a repository's .cursor/skills folder.

How Dalo compares

skills.sh is great for discovering public skills and installing them into almost any agent. agentfiles puts your agents' files into an Obsidian UI. Dalo covers the team side: exact commit pins, explicit approval, and sync that never overwrites unmanaged folders. Find a skill on skills.sh, then let Dalo pin and deliver it. See the full comparison.

Installation

Dalo supports macOS on Apple Silicon, and Linux on x86_64 and ARM64. Intel Macs are not supported: that build was discontinued with 1.0, and cargo install dalo compiles from source there. Windows is not currently supported.

Hosted installer

curl -fsSL https://dalo.sh/install.sh | sh

The installer selects the matching release, always verifies its SHA-256 checksum, and installs dalo into ~/.local/bin by default. If cosign is on PATH, it also verifies the release's Sigstore provenance.

Require provenance verification explicitly:

brew install cosign
curl -fsSL https://dalo.sh/install.sh | DALO_VERIFY=required sh

Set DALO_INSTALL_DIR to choose another binary directory. On unusual Linux systems, DALO_LINUX_LIBC=gnu or DALO_LINUX_LIBC=musl overrides automatic libc detection.

Node.js

Use Node.js 20 or newer:

npx getdalo --version
# or
npm install --global getdalo

The small launcher downloads the matching release on first use, verifies its SHA-256 checksum, and caches the executable in ~/.cache/dalo.

Package managers

# Homebrew (macOS)
brew install sebastian-software/tap/dalo

# Cargo Binstall
cargo binstall dalo

# mise with the GitHub Releases backend
mise use -g github:sebastian-software/dalo

# Nix (builds from source and Cargo.lock)
nix profile install github:sebastian-software/dalo

# crates.io (requires Rust 1.94 or newer)
cargo install dalo

Update notices

Successful interactive commands check for a newer GitHub release at most once per day. The check is advisory: Dalo never replaces its own executable. When an update is available, it prints the upgrade command for the detected installation method once for that version — in the same run when the release API answers within 150 milliseconds, otherwise on the next command, which reads the recorded answer without any network access. Network and cache failures are ignored, and checks are disabled for JSON output, CI, and DALO_OFFLINE=1. Set DALO_UPDATE_CHECK=never to opt out.

You can also ask your agent to install Dalo: dalo.sh publishes an llms.txt index and an agent-oriented installation guide, so an agent pointed at the site finds the verified install path on its own.

For manual archives, upgrades, shell completions, and removal, see the installation guide and uninstall guide.

Documentation

Architecture decisions, RFCs, and implementation history remain available in the project documentation, but the CLI and command reference describe the product you can use today.

Related

harness-relay is the complementary tool of the same agent line: Dalo distributes the skills your agents read, while harness-relay delegates one bounded invocation to an installed agent harness and returns a normalized outcome.

Development

Dalo is a Rust CLI with a reusable library core, dual-licensed under MIT or Apache-2.0.

cargo fmt --check
cargo test --locked
cargo clippy --locked --all-targets --all-features -- -D warnings
cargo run -- --help

See CONTRIBUTING.md for the complete development and release workflow.

Maintaining this README

Edit README.md.src, then run mise run readme:write. See README setup and checks for the contributor workflow.