Kasetto
📼 A declarative AI agent environment manager, written in Rust
Last verified:
What is Kasetto?
Kasetto is a declarative AI agent environment manager written in Rust that lets you define your entire AI agent setup in a single YAML configuration file. It manages skills, commands, and MCP (Model Context Protocol) servers across multiple AI agents, installing them into the correct agent directories and automatically merging MCP configurations into each agent's native settings file. The tool is designed to eliminate setup drift between machines and teammates by providing reproducible environments that can be shared via a version-controlled config file.
Key features include support for 21 built-in agent presets (Claude Code, Cursor, Codex, Windsurf, Copilot, Gemini CLI, and more), the ability to pull skills from GitHub, GitLab, Bitbucket, Codeberg/Gitea including self-hosted and enterprise repositories, and both global and project-scoped installations with separate lockfiles. Kasetto is built for speed with content hashing and lockfile diffing so only changed items get updated during sync, and it provides CI-friendly features like --dry-run for previewing changes, --json for structured output, and proper exit codes for automation.
Kasetto is primarily for developers and teams working with AI coding agents who need to version, share, and reproduce their skill and MCP server setups. It's ideal for onboarding new team members quickly (one command instead of manual setup steps), maintaining consistent environments across a team, setting up new machines instantly, and integrating AI agent configurations into CI/CD pipelines for validation and reproducibility.
Kasetto pricing
Pricing model: Freemium
Kasetto is completely free and open-source. It is available on GitHub under an open-source license with no paid tiers or enterprise plans. The tool can be installed via standalone installer script, Homebrew (brew install pivoshenko/tap/kasetto), or Cargo (cargo install kasetto) at no cost. All features including multi-agent support, enterprise/private repository access, remote config sharing, and CI/CD integration are available in the free open-source version.
Kasetto pros
- Declarative configuration with a single YAML file for entire setup
- 21 built-in agent presets including Claude Code, Cursor, Codex, Windsurf, Copilot, Gemini CLI
- Multi-agent support - write once, sync to all agents simultaneously
- Pulls from GitHub, GitLab, Bitbucket, Codeberg/Gitea including self-hosted and enterprise repos
- MCP server management with automatic merging into agent native settings files
- Global and project scopes with separate lockfiles for flexibility
- Written in Rust for speed with instant sync operations
- Content hashing and lockfile diffing updates only what changed
- CI-friendly with --dry-run, --json output, and proper exit codes
- Single static binary with no runtime dependencies for macOS, Linux, Windows
- Interactive TUI browser for listing installed skills and MCPs
- Command-line completions for bash, zsh, fish, powershell
- Extends feature to inherit from parent configs for team base configurations
- Remote config support via HTTPS URLs for team-wide sharing
- --dry-run preview before making any changes to disk
- SHA256 checksum verification for self-update integrity
- Does not run skill code or overwrite existing MCP server entries
- Environment variable-based authentication (no credentials file needed)
- Doctor command for environment health checks and diagnostics
- Clean command to remove all installed skills and MCP entries
- Self-uninstall command for complete teardown including binary
Kasetto cons
- No graphical user interface (only terminal TUI or plain text output)
- Requires manual installation of the binary (no package auto-update for Homebrew/Cargo)
- MCP servers merge automatically without confirmation prompt (must use --dry-run to preview)
- No built-in GUI for managing skills or viewing configurations
- Interactive TUI may not work well in all terminal environments
- Learning curve for YAML configuration syntax if new to declarative configs
- Limited to skills/MCPs/commands - does not manage agent settings beyond MCP merging
- Custom agents require manual destination path specification
- No built-in skill marketplace or discovery (must know source URLs)
- Private repos require environment variable token setup for authentication
- No web-based dashboard or remote management interface
- Lockfile depth limited to maximum chain depth of 8 for extends
- No built-in skill validation beyond what the agent itself provides
- Self-update only works for standalone installer, not Homebrew/Cargo installs
- No native Windows installer (must use PowerShell script or package manager)
Frequently asked questions about Kasetto
What is Kasetto and what problem does it solve?
Kasetto is a declarative AI agent environment manager that solves the problem of messy, manual AI agent setups. It eliminates the need to manually install skills and MCP servers across different agents (Claude Code, Cursor, Codex, etc.), removes setup drift between machines and teammates, and provides reproducible environments. With Kasetto, one YAML config describes your entire setup - skills, MCP servers, and target agents - which you can commit, share, and reproduce identically everywhere with one command.
What is the basic workflow for using Kasetto?
First run kst init to generate a starter kasetto.yaml config file, then edit it to add your desired skills, MCP servers, and target agents. Finally run kst sync to pull the skills and MCP servers and install them into the right agent directories. Kasetto merges MCP configs into each agent's native settings file automatically. Next time you run sync, only what changed gets updated.
Which AI agents does Kasetto support?
Kasetto has 21 built-in presets including Claude Code, Cursor, Codex, Antig ravity, Windsurf, Copilot, Gemini CLI, and more. The agent field accepts a single value or a list, allowing you to target multiple agents simultaneously with one sync command.
Can I share my Kasetto config with my team?
Yes. Host a shared kasetto.yaml somewhere reachable over HTTPS (public or private), then have each developer run kst sync --config https://example.com/team/kasetto.yaml. You can also use the extends feature to inherit from a parent config, allowing a team base config to be shared while individual projects override or extend it.
How does Kasetto handle authentication for private repositories?
Kasetto reads tokens from environment variables per host. For GitHub/GitHub Enterprise use GITHUB_TOKEN or GH_TOKEN, for GitLab/self-hosted GitLab use GITLAB_TOKEN or CI_JOB_TOKEN, and for Bitbucket Cloud use BITBUCKET_EMAIL plus BITBUCKET_TOKEN. The same token-based authentication applies when fetching remote configs via --config https://...
What is the difference between global and project scope?
By default, skills are installed globally into the agent's home-directory path. Add scope: project to your config or pass --project on the command line to install into the current project directory instead. Each scope has its own lockfile. The --project and --global flags always override whatever scope is set in the config file.
How do I preview changes before syncing?
Use kst sync --dry-run to see what would happen without touching anything on disk. This is especially useful in CI to validate that sources resolve and the plan matches expectations. You can combine --dry-run with --json for structured output in CI pipelines.
What commands does Kasetto provide?
Kasetto provides: kst sync (pull skills + MCP servers), kst sync --dry-run (preview changes), kst sync --json (structured output), kst list (browse installed skills interactively), kst list --json (dump as JSON), kst init (scaffold config), kst doctor (health check), kst clean (remove all installed skills/MCPs), kst self update (update to latest), kst self uninstall (complete teardown), and kst completions (generate shell scripts).
Is Kasetto safe to use with remote configs and skills?
Yes. Kasetto follows a tracked-only principle: it does not run skill code, does not overwrite existing MCP server entries, and does not require credentials files. Self-update verifies downloaded binaries against SHA256 checksums. For remote sources, prefer pinning to immutable refs (ref: v1.2.3 or commit SHA) for stable rollouts. In CI, use --dry-run to validate without writing changes.