Rust CLI · macOS & Linux · v__DALO_VERSION__
Dalo is the missing layer between "I found a useful skill" and "our agents can rely on this." Keep local experiments and team skills in Git, resolve one approved set, and link it into the folders your agents already read.
curl -fsSL https://dalo.sh/install.sh | sh
$ dalo sync
refresh company clean · fast-forward
link review → ~/.agents/skills/review
link release-notes → ~/.claude/skills/release-notes
shadow copy-editing company over oss
block deploy slot held by unmanaged skill
2 linked · 1 shadowed · 1 blocked · 0 overwrittenThey encode how your team works. But most of them still live in one machine's folder, a pasted snippet, or a chat thread. Over time, versions diverge, ownership blurs, and the same skill behaves differently for everyone.
The usual flow
With Dalo
All skills live in Git, locally and across the team. Dalo's store becomes the single, versioned source of truth, so the team repository stays a clean input and your agent folders stay an output.
The resolver is a pure function: given your sources and config, it returns the same result every time. Source priority decides conflicts, lower wins. Re-running on the same inputs is byte-for-byte identical.
same name review · one slot · highest priority linked
Dalo only writes paths it owns. It links resolved skills as directory
symlinks, removes only the links it created, and never overwrites a real
file or folder it didn't make. --dry-run prints the plan and
writes nothing.
Public skill repositories are often catalogs, not one-skill packages. Add a catalog source, inspect its inventory, select only the skills you want, and keep the selection pinned with read-only drift checks.
Shared conventions can live as versioned Markdown packs. Dalo renders them into explicit managed blocks, preserves everything outside those markers, and warns when active packs declare overlapping topics.
Dalo is a small pipeline: it turns many skill sources into one reliable set, then links that set into the folders your agents already read.
The agent folder is an output, not the database. That one boundary keeps team repos clean, local experiments private, and existing files safe to inspect.
A path that scales from a single developer to the whole org, one step at a time.
An agent wrote a useful skill straight into its own folder. Bring it under management without losing the original. Dalo copies it into your local source first.
dalo adopt release-notes.local
Connect a team repository of shared skills. Dalo checks it out into the store and tracks its branch.
dalo source add company git@github.com:acme/agent-skills.git
Resolve every active source into one set and link it into your agent folders. Safe to run any time; dirty edits block instead of getting lost.
dalo sync
When a local skill proves useful, send it upstream through a PR-first flow so the whole team gets it. On the roadmap for a future release.
dalo promote release-notes --target company
Install with the hosted script, Cargo Binstall, Cargo, or a prebuilt archive from
GitHub Releases.
Dalo shells out to git for source operations; there is no daemon.
curl -fsSL https://dalo.sh/install.sh | sh
Prefer Rust tooling? crates.io supports cargo binstall dalo and cargo install dalo.
# sandbox: no real agent folders touched
$ export DALO_STORE="$(mktemp -d)/store"
$ export DALO_TARGET="$(mktemp -d)/skills"
$ dalo init
$ dalo target link generic "$DALO_TARGET"
# add a local skill and sync
$ mkdir -p "$DALO_STORE/local/skills/review"
$ printf '# Review\n' > "$DALO_STORE/local/skills/review/SKILL.md"
$ dalo syncPrefer a dry run first? Every command takes --dry-run.
Dalo is conservative on purpose. It protects the work that's already on your disk, and it makes every change visible before and after it happens.
If a real skill folder already holds a slot, Dalo reports the conflict and leaves it exactly where it is. It never overwrites what it didn't create.
A newly active skill stays pending until you approve it: by skill, source, author, or org. Scheduled syncs apply existing approvals but never grant new ones.
Same-name skills resolve by priority and the rest are reported as shadowed, not silently dropped. status explains every state.
Edited a team skill in place? The source is dirty, and sync stops for it instead of discarding your change. The default is no data loss.
The same planning path drives real runs and --dry-run. See exactly which symlinks would be created or removed before anything changes.
dalo doctor checks store structure, lockfiles, Git auth, target paths, and broken symlinks, so you can trust the result.
Dalo syncs the resolved set into normal skill directories. Your agents keep reading the same paths. They never know Dalo is there.
Codex and OpenClaw both default to ~/.agents/skills, so Dalo de-duplicates the shared directory and links each slot once.
~/.agents/skillssupported~/.claude/skillssupported~/.agents/skillssupported~/.hermes/skillssupportedany path you choosesupportedunverifiedexperimentalSingle-user installers are useful for trying a skill. Dalo starts where that flow gets awkward for teams: review, provenance, version drift, and safe rollout across several agent folders.
Weak once a team needs review, shared versions, and the same result on every laptop.
Great for personal setup, risky when skill rollout can overwrite unrelated environment files.
Useful for one external source, awkward for catalogs where you only want three skills out of forty.
No drift detection, no provenance, and no clean path from local experiment to team standard.
Dalo is v__DALO_VERSION__. The V1 and V1.1 surfaces work today: local, team, and catalog sources; deterministic resolution; safe sync; adoption; diagnostics; and instruction packs. Here's what's intentionally deferred to later releases.
Stop fighting drift. Keep your team's agent skills in Git, resolve them once, and sync with confidence.