Rust CLI · macOS & Linux · v0.11.0
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. When something is off, Dalo tells you exactly what to run next — no archaeology.
curl -fsSL https://dalo.sh/install.sh | sh
$ dalo sync
dalo store: /tmp/dalo/store
applied create ~/.agents/skills/review -> /tmp/dalo/store/local/skills/review
applied create ~/.claude/skills/review -> /tmp/dalo/store/local/skills/reviewThey 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.
A team repository can combine its own skills with external skill sets.
Use dalo team catalog add to pin an immutable Git commit in
dalo.toml, then apply explicit filters: +
includes a skill and - excludes it. An empty list selects all.
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.
Install a background job with dalo autosync install and Dalo
keeps your agent folders current on a schedule through the native
scheduler. Scheduled runs stay fail-closed: they apply existing approvals
but never grant new ones or push past a blocking audit.
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. Its checked-in dalo.toml can also compose commit-pinned external catalogs, so every teammate resolves the same declared selection.
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 Homebrew, the hosted script, npx getdalo, 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 Node? Run npx getdalo --version or npm install --global getdalo. Prefer Rust tooling? crates.io supports cargo binstall dalo and cargo install dalo.
On Windows? Dalo runs under WSL; use the standalone command from your WSL shell.
Installing through an AI agent? Point it to dalo.sh/install.md.
# sandbox: no real agent folders touched
$ export DALO_STORE="$(mktemp -d)/store"
$ export SKILLS_DIR="$(mktemp -d)/skills"
$ dalo init
$ dalo target link generic "$SKILLS_DIR"
# try a real public catalog
$ dalo source add-catalog sebastian https://github.com/sebastian-software/skills.sebastian-software.com.git
$ dalo source inspect sebastian
$ dalo source select sebastian pr-review
$ dalo audit sebastian:pr-review
$ dalo approve skill sebastian:pr-review
$ dalo sync
security preflight: deterministic checks and compatible cached findings only; sync did not run an agent reviewer; passing is not a safety guaranteeWatch the 15-second secure-sync demo above, or download the MP4. Prefer 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.
Adding a source is the trust decision: team repositories you add are trusted, and their skills undergo the deterministic security preflight. Catalog skills go further — each stays pending until you approve it with dalo approve skill source:skill. Scheduled runs apply existing decisions but never make new ones.
Every active skill is checked before sync. High or critical findings block links until explicitly accepted. dalo audit shows the deterministic evidence, and an optional isolated agent reviewer can add findings but can never approve content.
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.
Helpful by default
Mistype a command and Dalo suggests the right one. Reference a skill that does not exist and it lists the ones that do. When sync blocks, the output is the fix: the exact command to run next.
dalo doctor turns a broken state into a runnable to-do list,
so getting unstuck does not mean searching docs or reconstructing state.
$ dalo synk
error: unrecognized subcommand 'synk'
tip: a similar subcommand exists: 'sync'
$ dalo approve skill company:relese-helper
error: skill 'company:relese-helper' was not found; known skills: company:new-skill, company:release-helper
$ dalo sync
pending approval: sebastian:tech-docs (run: dalo approve skill sebastian:tech-docs)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 v0.11.0. These features work today: local, team, and catalog sources; deterministic resolution; security audits and review gates; 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.