Dalo
Your team's agent skills, versioned like code.
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
# macOS or Linux with the hosted installer
|
# Node.js 20 or newer, without a global install
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.
2. See which agents are installed. Detection is read-only and names the default skill directory of every supported agent.
3. Link the agents you use. Repeat for every agent; generic takes an
explicit path for anything folder-based.
4. Add your team's skill repository. Dalo clones it into the store and runs a deterministic security preflight on every skill it finds.
5. Sync. One command resolves the approved set and links it into every configured target.
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.
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:
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:
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
syncblocks 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
syncdoes 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-runshows planned changes without writing them- conflicts stay visible in
statusuntil 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 refreshreports 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 doctorturns 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
|
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:
| DALO_VERIFY=required
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:
# or
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)
# Cargo Binstall
# mise with the GitHub Releases backend
# Nix (builds from source and Cargo.lock)
# crates.io (requires Rust 1.94 or newer)
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
- Getting started
- Dalo assistant
- 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
- 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.
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.
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.