Kasetto
Kasetto syncs skills, commands, MCP servers, and instructions to 23 AI coding agents from one YAML file.
If your team runs two or more coding agents and still hand-copies prompts between them, Kasetto is the cleanest fix I've seen: one YAML file, ref pinning, and secret placeholders that keep tokens out of Git. The managed-block merge into CLAUDE.md and AGENTS.md is what stops it from trampling your notes. On a single agent with a few local prompts, the YAML-and-provider-auth setup cost outweighs the benefit.
Verified 1d ago · liveness 67/100 · cite: rightaichoice.com/tools/kasetto
- Developers running two or more AI coding agents who want one source of truth for prompts and configs
- Teams sharing agent instructions and MCP configs across repos with commit pinning
- CI/CD pipelines that need to verify and reproduce an AI agent environment on every build
- Organizations that must inject MCP and API secrets without committing credentials
- Non-developers or anyone who does not work with AI coding agents
- Users who prefer a GUI and will not manage configuration through a CLI and YAML files
- Teams whose sync environment cannot reach their Git sources or secret stores
We scan live Reddit threads, YouTube comments, X posts, G2 reviews and other communities — and hand you an honest verdict in under a minute.
- Honest verdict, not marketing
- Real pros & cons from real users
- Attributed quotes with receipts
3 free scans · no card needed
Skip Kasetto if you run a single coding agent with a few local prompts, prefer a GUI over a CLI plus YAML, or cannot reach Git and a secret store from the machine that runs `kst sync`.
The Kasetto project is published under MIT and Apache 2.0, so the tool itself carries no license fee — the cost is the setup time to write kasetto.yaml, wire refs and branches, and authenticate whichever secret backends you use. That makes it cheap next to commercial agent-console products that charge per seat, and comparable in spirit to dotfile managers you maintain yourself, except Kasetto already knows the four asset kinds and each agent's native layout.
In short
Kasetto — Kasetto syncs skills, commands, MCP servers, and instructions to 23 AI coding agents from one YAML file. Best for Developers running two or more AI coding agents who want one source of truth for prompts and configs, Teams sharing agent instructions and MCP configs across repos with commit pinning, CI/CD pipelines that need to verify and reproduce an AI agent environment on every build. Free to use.
What people actually say about Kasetto — is it worth it?
We scanned public community sources for Kasetto on Aug 30, 2026 and could not establish that the discussion we found is about this tool rather than something else sharing its name. Our own analysis of that scan says the posts were off-subject. Rather than publish a sentiment score built on the wrong subject, we publish nothing here and re-run the scan.
Viability Score
How well maintained and how widely used is Kasetto? Built from what the vendor actually publishes (docs, changelog, tutorials, integrations, pricing), whether the site is live, and how much real users discuss it. How we calculate this
Last calculated: October 2026
How we score →Key Features
- Declarative YAML config for skills, commands, MCP servers, and instructions
- Sync one config to 23 built-in agent presets including Claude Code, Cursor, Codex, Copilot, and Antigravity
- Pull assets from public or private GitHub, GitLab, Bitbucket, or self-hosted Git repos
- Wildcard "*" to sync every skill or instruction from a source
- sub-dir and path resolution for skills in non-standard repo locations
- Ref pinning to branch, tag, or commit for reproducible setups
- YAML extends for composable, reusable configuration
- kst sync --config <url> to sync from a shared remote team config
- Non-destructive managed-block merge into CLAUDE.md, AGENTS.md, and .cursor/rules
- Secret placeholders (${kst:*}) resolved at sync time from 1Password, Vault, AWS, GCP, Azure, KeePass, pass/gopass,
- Incremental sync using content hashing and a lock file
- Dry-run mode (kst sync --dry-run) to preview every change before applying
- JSON output (kst sync/list/doctor/clean --json) and real exit codes for CI pipelines
- kst doctor to report version, lock file location, install paths, last sync time, and failed skills
- Single static binary for macOS, Linux, and Windows via curl, PowerShell, Homebrew, or cargo
About Kasetto
Kasetto is a declarative AI agent environment manager, written in Rust, that keeps multiple AI coding agents fed from a single kasetto.yaml file. You list your sources — Git repositories holding skills, commands, MCP configs, and instructions — point them at agents like Claude Code, Cursor, Codex, Copilot, or Antigravity, and run `kst sync`. Kasetto transforms each asset into every target agent's native format and merges it in, so you write once and ship everywhere. Sources can be public or private repos on GitHub, GitLab, Bitbucket, or self-hosted Git. You select assets with a wildcard `"*"`, by name, or by resolving non-standard locations through `sub-dir` and `path`, and you can track a `branch` or pin a `ref` to a tag or commit. The `extends` key composes configs, so shared team baselines don't have to be copy-pasted between projects. Secrets stay out of the repo. Placeholders like `${kst:op:Private/Vercel/token}` or `${kst:aws:prod/db#password}` resolve at sync time from 1Password, HashiCorp Vault, KeePass, AWS Secrets Manager, Google Secret Manager, Azure Key Vault, pass/gopass, macOS Keychain, environment variables, or a credentials.yaml file. Syncs are incremental: content is hashed and diffed against a lock file, so only changed items are touched. Managed-block merging writes into aggregate files like CLAUDE.md, AGENTS.md, and .cursor/rules without clobbering hand-written text, while `kst sync --dry-run` previews changes and `--json` output with real exit codes fits CI. It ships as one static binary for macOS, Linux, and Windows. Unlike dotfile managers or hand-rolled copy scripts, Kasetto understands the four asset kinds and each agent's file layout.
Behind the Verdict
Pick Kasetto the moment your agent count goes above one. The recurring pain of multi-agent work isn't writing the prompt — it's keeping Claude Code, Cursor, and Codex from drifting apart. A single kasetto.yaml with wildcard sources and `kst sync` collapses that into one command, and ref pinning means the whole team lands on the same versions. We'd reach for it in CI, too. `kst sync --dry-run` and `--json` with real exit codes let a pipeline verify that agents' configs are current and fail the build if not. Content hashing against a lock file keeps syncs in the seconds range rather than rewriting everything each run. The secret-placeholder system is the part teams underrate. Tying `${kst:*}` to 1Password, Vault, AWS, or Keychain means MCP server tokens and API keys never enter a repo or the lock file. That alone often justifies adoption at orgs with security review. Where it bites: the whole model assumes comfort with YAML, Git refs, and provider auth. Non-developers, or anyone who wants a GUI, will bounce off. You also need your sync environment to actually reach the Git sources and secret stores — air-gapped or locked-down CI without those will need extra plumbing. The closest alternative is a generic dotfile manager or a home-grown shell script, but neither knows that a skill is a directory with a SKILL.md or that instructions belong in managed blocks inside CLAUDE.md. Kasetto is narrower than a full config-management tool by design, and that focus is why it works. One caveat to keep on your radar: the name is easy to confuse with newer Hacker News projects like Kassette and Kastor. Confirm you're installing `kasetto` from pivoshenko before trusting a random tap.
Researching Kasetto? Get your full AI stack in 60 seconds.
Free, no signup — tell us your goal and get tools matched to your budget & existing stack.
Real-world workflow fit
Concrete scenarios for the personas Kasetto actually fits — and what changes day-one when you adopt it.
Write kasetto.yaml with a team skills source, an mcps section pointing at a private MCP pack, and `agent: [claude-code, cursor]`. Wire ${kst:op:...} placeholders for the tokens those MCP servers need, then run `kst sync --dry-run` to preview before applying.
Outcome: Every developer gets identical skills, commands and MCP configs, tokens are never committed, and version bumps show up as `git-pr-create 1.4.2 → 1.5.0` on the next sync instead of being hand-copied.
Check the YAML config and lock file into the repo, export the secret-store token as an environment variable, and call `kst sync --json` in the pipeline so each build installs exactly the pinned skills and MCPs.
Outcome: Real exit codes fail the build when a sync breaks, and `kst doctor --json` gives a machine-readable view of install paths and any skills that failed.
Keep a base config with an `extends` hierarchy — an org-wide base that each project overrides with a few extra skills or a different branch — and hand out the shared config with `kst sync --config <url>`.
Outcome: Projects inherit the org standard without copy-pasting config, and managed blocks keep the generated section of CLAUDE.md, AGENTS.md and .cursor/rules separate from hand-written notes.
Use Cases
- Sync a shared set of skills and commands from GitHub to every developer's Claude Code and Cursor instances.
- Inject API tokens via 1Password or Vault into agent MCP configs without hardcoding secrets.
- Wire `kst sync` into a CI pipeline so every build uses an identical agent skill set.
- Define an `extends` base config for an organization and override it with per-project additions.
- Preview a new skill pack across dozens of repos with `--dry-run` before applying it.
- Move from manual CLAUDE.md editing to a declarative, version-controlled setup with managed blocks.
- Use `sub-dir` and `path` to pull skills that live outside a repo's root or standard skills/ folder.
- Run `kst doctor` to audit install paths, lock file state, and skills that failed on the last sync.
Limitations
- Kasetto is explicitly CLI-only: "every action has a dedicated subcommand," so it assumes comfort with YAML and Git rather than offering a GUI.
- Setup complexity can rise with secret injection, since tokens must be wired up through placeholders backed by providers like 1Password, Vault, KeePass, or AWS Secrets Manager before sync will resolve them.
- Because it syncs assets into aggregate files such as CLAUDE.md and AGENTS.md via managed blocks, hand-edits need to respect those blocks.
- It syncs agent configuration and assets — it does not itself run or host your agents.
as of 2026-10-11
Verification history
We have re-verified Kasetto 10 times since . Each pass re-reads the vendor's own pages and re-checks every listed field against that evidence; passes where nothing had changed are marked as such.
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
Showing the 6 most recent of 10 verification passes.
Free to cite with attribution — this page re-verifies continuously.
12-month cost
Project the real annual outlay, including the implied monthly cost when only an annual tier is published.
Vendor list price only. Add-on usage, seat overages, and contract minimums are surfaced under Hidden costs & gotchas.
Plans compared
For each published Kasetto tier: who it actually fits, and what it adds vs. the previous tier. Cross-reference the cost calculator above for projected annual outlay.
Open Source
$0
Ideal for
Developers and teams already committed to running one or more AI coding agents who want a version-controlled source of truth instead of hand-edited configs.
What this tier adds
Starting tier — MIT / Apache 2.0 licensed, with declarative YAML, 23 agent presets, secret placeholders, managed-block merge, incremental sync, and the single static Rust binary.
Where the pricing makes sense
The company stage and team size where Kasetto's pricing actually pencils out — and where peers do it cheaper.
The Kasetto project is published under MIT and Apache 2.0, so the tool itself carries no license fee — the cost is the setup time to write kasetto.yaml, wire refs and branches, and authenticate whichever secret backends you use. That makes it cheap next to commercial agent-console products that charge per seat, and comparable in spirit to dotfile managers you maintain yourself, except Kasetto already knows the four asset kinds and each agent's native layout.
Setup time & first value
How long it actually takes to get something useful out of Kasetto — broken out by persona, not the marketing-page minute.
Developer familiar with Git: roughly 10–15 minutes from `kst init` to a first working `kst sync` — generate the starter config, point `source` at a repo, pick an `agent`, and preview with `--dry-run`. The time grows if you add secret backends: 1Password or Keychain are quick, while Vault or the cloud secret managers may need their own auth setup before your MCP tokens resolve. Teams can cut
Switching to or from Kasetto
How to bring data in from common predecessors and how to get it back out — written for the switcher, not the buyer.
- →From hand-edited CLAUDE.md / AGENTS.md / .cursor/rules: move the shared content into a sourced instruction, run `kst sync`, and let managed blocks own the generated section so hand-written notes stay outside it.
- →From copied prompt folders between repos: put the prompts in a Git repo as skills or commands, then reference that source from kasetto.yaml with a pinned `ref`.
- →From a team-wide dotfile or sync script: reproduce each destination as an `agent` preset or a `destination` path, and let content hashing and the lock file replace the whole-copy logic.
Integrations
Resources & Guides
- Documentationkasetto.dev
Docs · Kasetto
Full product docs from kasetto.dev
- Documentationkasetto.dev
Installation · Kasetto
Full product docs from kasetto.dev
- Documentationkasetto.dev
Configuration · Kasetto
Full product docs from kasetto.dev
- Documentationkasetto.dev
Commands · Kasetto
Full product docs from kasetto.dev
- Documentationkasetto.dev
Cookbook · Kasetto
Full product docs from kasetto.dev
- Resourcegithub.com
Kasetto · Kasetto
Helpful link from github.com
Tutorials & Learning
YouTube returned 6 videos for “Kasetto”, and we withheld 6: 6 could not be judged, because “Kasetto” is a single word that other videos use for other things. We are showing none, because we could not prove any of them are about Kasetto.
Official links
Tools that pair well with Kasetto
Common stack mates teams adopt alongside Kasetto, with the specific reason each pairing earns its keep.
Warp
Warp Factories runs fleets of cloud coding agents across your SDLC, defined in code as factory.yaml.
Chrome DevTools MCP
Open-source MCP server that gives coding agents live Chrome DevTools for debugging, traces, and browser automation.
Kiro
Kiro turns prompts into specs, validates them, then ships with parallel AI coding agents
Featured Head-to-Head Comparisons
Kasetto vs Spider Cloud
Spider Cloud and Kasetto solve completely different problems. Spider Cloud is a web scraping API for feeding data into AI agents, while Kasetto is a CLI tool for managing the configuration of those agents. If you need fresh web content for RAG or LLMs, choose Spider Cloud. If you juggle multiple coding agents and want to sync configs declaratively, choose Kasetto. They're complementary, not competitive.
Kasetto vs Voyage Ai
Choose Voyage AI if you need high-accuracy, domain-specific embedding and reranking models for enterprise RAG pipelines, especially in finance or legal, with compliance (SOC 2/HIPAA) and support for long contexts (32K tokens). Choose Kasetto if you're a developer managing multiple AI coding agents and want a free, declarative way to synchronize skills, commands, MCPs, and secrets from a single YAML file. They solve entirely different problems.
Kasetto vs Temporal Ai
If your challenge is making AI agents survive crashes and coordinating multi-step microservices, Temporal's durable execution platform is unmatched. But if you're tired of manually configuring Claude Code, Cursor, and Copilot across projects, Kasetto's one-YAML sync will save you hours. They solve different problems — pick based on whether your pain point is reliability or configuration chaos.
Alternatives to Kasetto
View allWarp
Warp Factories runs fleets of cloud coding agents across your SDLC, defined in code as factory.yaml.
Chrome DevTools MCP
Open-source MCP server that gives coding agents live Chrome DevTools for debugging, traces, and browser automation.
Frequently Asked Questions
Best-of guides
Used Kasetto? Help shape our editorial sentiment research.