Dalo
One source of truth for the skills your AI agents run.
Dalo turns scattered skill folders into shared, versioned infrastructure. Keep team skills in Git, private experiments local, and deliver one approved, deterministic skill set to Codex, Claude Code, OpenClaw, Hermes, or any folder-based agent.
Your agents keep reading the folders they already understand. Dalo handles everything behind them: sources, priorities, approvals, conflicts, drift, and safe synchronization.
Visit dalo.sh · Watch the 20-second demo · Get started
Stop copying skills between agents
Skills quickly become operational knowledge: how your team reviews code, investigates incidents, ships releases, uses internal tooling, and makes the judgment calls that generic prompts cannot capture.
Copying those skills by hand works until they matter. Then every machine has a slightly different version, local improvements get lost, public skills change upstream, and nobody can say with confidence what an agent is actually using.
Dalo gives that knowledge a lifecycle:
- Share it in Git. Team repositories stay reviewable and versioned.
- Keep experiments local. Private work remains separate until it is ready.
- Resolve it predictably. Source priority and lockfiles produce the same approved skill set from the same inputs.
- Deliver it everywhere. One sync links skills into every configured agent folder.
- Stay in control. Dalo reports conflicts and drift instead of overwriting files or silently trusting new code.
See it work
Install Dalo on macOS or Linux:
# macOS with Homebrew
# macOS or Linux with the hosted installer
|
Connect an agent, add your team's skill repository, and sync:
The skills from company now appear in Codex's normal skill directory. Link
Claude Code, OpenClaw, Hermes, or a generic folder and Dalo will deliver the same
resolved set there too.
Run dalo status to see managed, unmanaged, shadowed, blocked, or pending
skills. Run dalo doctor when you want a focused health check.
Prefer Node.js? Run the same CLI without a global install:
The full terminal session is available as an asciicast recording.
How Dalo fits
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.
That boundary is what makes Dalo predictable: Git repositories remain clean inputs, local work has a private home, and agent directories contain only the resolved links Dalo owns. Existing unmanaged files remain yours.
Built for the whole skill lifecycle
Share team knowledge
A team source is a Git repository containing skills. Add it once and sync
refreshes clean tracking sources before resolving and linking the final set.
When multiple sources offer the same skill name, source priority decides which one is linked. The other candidates remain visible as shadowed; they are not silently discarded.
Adopt what works locally
Agents often create useful skills directly in their own folders. Dalo can copy one into the private local source without taking over the original:
Replacing the original with a Dalo-owned link is a separate, explicit step:
Dalo does not commit adopted work automatically. You decide when an experiment is ready to move into a reviewed team repository.
Choose from public catalogs
A catalog can offer many skills without installing all of them. Inspect it, select only what you need, approve the exact skill, and sync:
Catalog selections are pinned. dalo source refresh <id> reports when selected
skills change, move, disappear, or gain same-catalog dependencies without
silently advancing the lock.
Share instructions that are not skills
Instruction packs keep reusable team conventions in versioned Markdown and render them as clearly marked managed blocks inside agent instruction files.
Dalo only owns the marked block. Everything else in the file remains untouched, and overlapping topics are reported as advisory warnings.
Safe by design
Skill management should be boring in the best possible way. Dalo is deliberately conservative:
- 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 before a skill reaches an agent folder- optional sandboxed reviews can reuse an installed Codex, Claude, or OpenCode CLI
- 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.
Agent support
| Agent | Default skill directory |
|---|---|
| Codex | ~/.agents/skills |
| Claude Code | ~/.claude/skills |
| OpenClaw | ~/.agents/skills |
| Hermes | ~/.hermes/skills |
| Any folder-based agent | user-provided path |
Cursor and OpenCode have experimental target IDs and currently require an explicit path. See agent integration for setup details.
Installation
Dalo supports macOS and Linux on x86_64 and ARM64. 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
# crates.io (requires Rust 1.93 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. 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:
Read https://dalo.sh/install.md and install dalo for me.
For manual archives, upgrades, shell completions, and removal, see the installation guide and uninstall guide.
Documentation
- Getting started
- Command reference
- Agent integration
- Dalo in CI
- Troubleshooting and FAQ
- Security policy
- 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.
Development
Dalo is an MIT-licensed Rust CLI with a reusable library core.
See CONTRIBUTING.md for the complete development and release workflow.