Your team's agent skills, versioned like code.
One reviewed set of skills, instructions, and hooks, synced into every agent on every machine. Ask your agent, or use the CLI. Dalo keeps it all in Git, resolves one approved set, and delivers it to the folders Claude Code, Codex, Cursor, and other agents already read.
Just ask: tell your agent what to install, update, or fix. It handles the commands and explains the result, while Dalo enforces its approval and ownership checks during sync.
Visit dalo.sh · Set up with your agent · Use Dalo through your agent
Paste this into your local coding agent:
Install Dalo, the agent skill manager.
The agent installs Dalo, connects its skill folder, and makes the bundled Dalo assistant available. No preinstalled Dalo skill is needed. Use an agent with local file and command access on macOS or Linux.
The matching assistant skill ships inside every Dalo binary. The first normal
invocation prepares it and makes it available in existing agent skill folders.
Later invocations verify it against the running package and update an unmodified
bundle when needed. No separate init or skill download is required.
Once set up, select the Dalo skill in your agent (for example, $dalo in Codex)
and ask in your own language:
- “What skills do I have, and what needs attention?”
- “Add my team's skill repository and make it available in this agent.”
- “Update my skills and show me what changed.”
- “Make the same skills available in Claude Code.”
- “I used skills.sh before. Move these skills to Dalo and keep my changes.”
The agent works from your actual installation, previews changes, and explains conflicts or approvals that need your decision. Dalo keeps unapproved catalog skills out of the sync and blocks source refresh when a checkout has local changes. These checks apply when your agent runs Dalo, just as they do in the terminal. The assistant uses the agent you already have, with no separate model, API key, or server.
Use Dalo through your agent covers installation, everyday requests, and working with existing skills. If your host caches its skill list, reload skills or start a new session after setup.
Install the binary with Homebrew, the hosted installer, or the npm launcher.
On Debian or Ubuntu with amd64 or arm64, use the verified package steps in
the installation guide when the
selected release includes matching .deb, checksum, and Sigstore assets;
otherwise, use the hosted installer.
# 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 --versionThen link the agents you use and add your team's repository:
# dalo creates ~/.dalo on first use; run `dalo init` for a sandbox or a project
dalo target detect
dalo target link codex
dalo target link claude
dalo target link cursor
dalo source add company git@github.com:acme/agent-skills.git
dalo sync
dalo statusUse your real repository URL in place of the example. No team repository yet? Start from a public catalog under When something is off. The command-line guide explains each step; additional install methods and verification are in Installation.
One sync resolves the approved set and links it into every configured target:
dalo store: ~/.dalo
target[codex]: ~/.agents/skills
existing noop target[codex]:/dalo -> store:/local/skills/dalo
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: 3 skills across 1 target (2 created, 1 unchanged)
security preflight: deterministic checks only
status lists managed, unmanaged, shadowed, blocked, and pending skills;
dalo doctor adds a focused health check. You can also ask your agent to check
these reports and explain what needs attention.
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 syncdalo store: ~/.dalo
target[claude]: ~/.claude/skills
existing noop target[claude]:/dalo -> store:/local/skills/dalo
synced: 1 skill across 1 target (1 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 syncConflicts, 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.
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:
- Dalo never overwrites unmanaged files or foreign symlinks.
- Catalog skills need an explicit selection and approval.
- High and critical preflight findings block sync.
--dry-runpreviews everything before anything is written.
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.
- Public catalogs. Select only the skills you want;
source refreshreports upstream movement instead of silently advancing the pin. Getting started - Team manifests. A team repository pins external catalogs to exact commits and defines the subset every member resolves, while approval stays personal. Team repository guide
- Project installations. Commit a
dalo-project.toml, and every clone restores the same pinned skills withdalo install. Project installations - Instruction packs. Share conventions as managed blocks in agent instruction files, leaving the rest of each file yours. Agent integration
- Updates through your agent. Refresh tracking sources and review catalog or project pin changes; your agent or host chooses when. Automate updates
- Portable plugins. Group skills, agents, and instructions in one package, with tools and hooks behind separate approvals. Plugins, tools, and hooks
- Adopt and promote. Copy a skill an agent wrote into your local source,
then open a team pull request with
dalo promote. Getting started - Doctor.
dalo doctorturns store, target, lock, and approval health into findings, each with its recovery command. Troubleshooting and FAQ
| 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.
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 and explicit approval. Find a skill on skills.sh, then let Dalo pin and deliver it. See the full comparison.
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.
curl -fsSL https://dalo.sh/install.sh | shThe 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 shSet 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.
Use Node.js 20 or newer:
npx getdalo --version
# or
npm install --global getdaloThe small launcher downloads the matching release on first use, verifies its
SHA-256 checksum, and caches the executable in ~/.cache/dalo.
# Homebrew (macOS)
brew install sebastian-software/tap/dalo
# Debian/Ubuntu (amd64/arm64): use only if the selected release has matching .deb assets
# https://dalo.sh/install.md#debian-packages
# 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 daloSuccessful interactive commands use the shared app-tracking client to check
for updates at most once per hour after a fresh response. A due check completes
at the end of the command with a 200 ms network budget; a cached check makes no
request. Notices include installation-specific upgrade instructions and are
throttled to once per release per day. Network and cache failures remain
advisory. JSON output, CI, noninteractive stderr, DALO_OFFLINE=1, and
DALO_UPDATE_CHECK=never disable checks.
All installation channels use the same GitHub release version, delivered through app-tracking from the CDN-cached oss-metrics feed. Releases must be at least one hour old before they become eligible; CDN and client caching can add delay. Upgrade instructions still match Homebrew, npm/npx, Cargo, Nix, Debian, mise, or the hosted installer. These update-only requests send no installed version, installation ID, repository hash, or usage counter. Dalo never replaces its own executable.
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.
- Five minutes to the first skill
- Getting started
- Dalo assistant
- Project installations
- Team repository guide
- Command reference
- Compatibility and stability
- Upgrading to 1.0
- Plugins, tools, and hooks
- Portable Agent Packages — experimental specification
- Agent integration
- Dalo in CI
- Comparison with skills.sh and agentfiles
- Troubleshooting and FAQ
- Uninstall
- Security overview
- Security policy
- Support
- Discussions
- Code of conduct
- Changelog
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.
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.
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 -- --helpSee CONTRIBUTING.md for the complete development and release workflow.
Edit README.md.src, then run mise run readme:write.
See README setup and checks for the contributor workflow.
TypeScript, React & Rust consulting
Experts in Agentic Software Development
Work with us · More open source
Copyright © 2026 Sebastian Software GmbH