Agent Skills

SKILL.md — ready to use

Tusky provides a ready-to-use SKILL.md that teaches AI agents how to use Tusky storage. Install it once and your agent knows how to create vaults, upload files, manage encryption, and follow best practices — no manual prompting needed.

The skill follows the Agent Skills open standard and works with Claude Code, and any other agent that supports it.

One-command install

Download SKILL.md directly, or use the commands below.

Project-level (recommended)

Add the skill to your project so all contributors get it automatically:

mkdir -p .claude/skills/tusky && curl -sL \
  https://docs.tusky.ai/skills/SKILL.md \
  -o .claude/skills/tusky/SKILL.md

Commit .claude/skills/tusky/SKILL.md to version control.

Personal (all projects)

Install globally so the skill is available in every project:

mkdir -p ~/.claude/skills/tusky && curl -sL \
  https://docs.tusky.ai/skills/SKILL.md \
  -o ~/.claude/skills/tusky/SKILL.md

Use it

Once installed, Claude Code discovers the skill automatically. Ask naturally:

save this file to Tusky
back up the src/ directory
store my session notes in a private vault

Or invoke it directly as a slash command:

/tusky back up the src/ directory to a private vault

What’s inside

The SKILL.md gives your agent:

• All 29 MCP tools — names, arguments, and when to use each one (including shared vault management)
• 12 key rules — private vs. public vs. shared vaults, encryption handling, SEAL protocol, deletion behavior, best practices
• 5 workflow patterns — context storage, project backup, file retrieval, multi-agent data sharing, shared vault collaboration

Note

The skill requires the MCP server to be configured. The SKILL.md teaches your agent how to use the tools — the MCP server provides the tools themselves.

Full SKILL.md

Save this to .claude/skills/tusky/SKILL.md in your project or ~/.claude/skills/tusky/SKILL.md for global access.

.claude/skills/tusky/SKILL.md

---
name: tusky
description: Store, retrieve, and manage files on Tusky decentralized storage. Use when the user asks to save files to Tusky, back up a project, store conversation context, or interact with Tusky vaults and files.
---

You have access to Tusky agentic storage via MCP tools. Tusky stores files in an encrypted hot cache and syncs them to the Walrus decentralized network for durable storage.

## Available MCP tools

### Account
- `tusky_account_info` — Get account info (email, plan, storage usage, encryption status)
- `tusky_account_link_sui` — Link a Sui wallet address to the account. Required for shared vault access. Args: `suiAddress`
- `tusky_account_unlink_sui` — Unlink the Sui wallet address from the account

### Vaults
Vaults are containers for files. Visibility is **immutable** after creation.

- `tusky_vault_create` — Create a vault. Args: `name` (required), `description`, `visibility` ("public", "private", or "shared", defaults to "private")
- `tusky_vault_list` — List all vaults
- `tusky_vault_get` — Get vault details. Args: `vaultId`
- `tusky_vault_update` — Update name or description. Args: `vaultId`, `name`, `description`
- `tusky_vault_delete` — Delete a vault. Args: `vaultId`, `force` (boolean, deletes even if vault has files)

### Files
- `tusky_file_upload` — Upload from a local path. Args: `filePath` (required), `vaultId` (required), `folderId`. Use this when you have filesystem access.
- `tusky_file_create` — Create from raw content. Args: `name` (required), `content` (required), `encoding` ("utf-8" or "base64", defaults to "utf-8"), `vaultId` (required), `folderId`. Use this for text content or when you don't have a file on disk.
- `tusky_file_download` — Download to a local path. Args: `fileId` (required), `outputPath` (required). Use when you need the file on disk.
- `tusky_file_read` — Read content inline. Args: `fileId` (required). Returns text for text files, base64 for binary. Use when you need to inspect content.
- `tusky_file_list` — List files. Args: `vaultId`, `folderId`, `limit`, `cursor`
- `tusky_file_get` — Get file metadata. Args: `fileId`
- `tusky_file_delete` — Soft-delete (moves to trash, restorable for 7 days). Args: `fileId`
- `tusky_file_retry` — Retry Walrus sync for a failed file, or retry all failed files. Args: `fileId` (optional, omit to retry all)

### Folders
- `tusky_folder_create` — Create folder. Args: `vaultId` (required), `name` (required), `parentId`
- `tusky_folder_list` — List folders. Args: `vaultId` (required), `parentId`
- `tusky_folder_get_contents` — Get files and subfolders. Args: `folderId` (required)
- `tusky_folder_update` — Rename a folder. Args: `folderId` (required), `name` (required)
- `tusky_folder_delete` — Delete folder. Args: `folderId` (required)

### Trash
- `tusky_trash_list` — List trashed items
- `tusky_trash_restore` — Restore from trash. Args: `id`
- `tusky_trash_delete` — Permanently delete a single item from trash (irreversible). Args: `id`
- `tusky_trash_empty` — Permanently delete all trash (irreversible)

### Shared vaults
Shared vaults use SEAL encryption for multi-party access. Members are identified by Sui address.

- `tusky_vault_grant_access` — Grant access to a shared vault by Sui address. Args: `vaultId` (required), `suiAddress` (required)
- `tusky_vault_revoke_access` — Revoke a member's access. Args: `vaultId` (required), `memberId` (required)
- `tusky_vault_list_members` — List all members of a shared vault. Args: `vaultId` (required)
- `tusky_vault_list_shared` — List shared vaults the user is a member of (not owner)

## Key rules

1. **Always check account info first** if you're unsure about storage quota or encryption status — call `tusky_account_info`.
2. **Private vaults are encrypted** — encryption is handled transparently. If encryption is not unlocked, you'll get a clear error. Tell the user to set `TUSKYDP_PASSWORD` in the MCP config.
3. **Shared vaults use SEAL encryption** — encryption is handled transparently via the SEAL protocol. Requires `TUSKYDP_SUI_PRIVATE_KEY` in the MCP config. Only available on Developer, Scale, and Enterprise plans.
4. **Public vaults are not encrypted** — do not store sensitive data in public vaults.
5. **Vault visibility is immutable** — you cannot change it after creation. Ask the user upfront if they want public, private, or shared.
6. **Prefer `tusky_file_create` for text content** — it's simpler than writing to disk and then uploading.
7. **Prefer `tusky_file_read` over `tusky_file_download`** when you just need to inspect content — it returns the data inline.
8. **Use `tusky_file_upload` for local files** — it handles encryption, presigned URLs, and upload confirmation automatically.
9. **Organize with folders** — for multi-file operations (backups, context storage), create a folder structure first.
10. **Files sync to Walrus automatically** — after upload, files start in `hot` status and background workers sync them to Walrus. No action needed.
11. **Deleted files go to trash** — they're restorable for 7 days. Use `tusky_trash_empty` only when the user explicitly wants permanent deletion.
12. **Shared vault members see all files** — any member can view and download all files in the vault, not just their own uploads.

## Common workflows

### Store conversation context
```
1. tusky_vault_create({ name: "agent-context", visibility: "private" })
2. tusky_folder_create({ vaultId, name: "2025-03-16-session" })
3. tusky_file_create({ name: "summary.md", content: "...", vaultId, folderId })
```

### Back up project files
```
1. tusky_vault_create({ name: "project-backup", visibility: "private" })
2. tusky_folder_create({ vaultId, name: "src" })
3. tusky_file_upload({ filePath: "/path/to/file", vaultId, folderId })
   (repeat for each file)
```

### Retrieve and analyze stored files
```
1. tusky_vault_list()
2. tusky_file_list({ vaultId })
3. tusky_file_read({ fileId })
```

### Share data between agents (public vault)
```
1. tusky_vault_create({ name: "shared-data", visibility: "public" })
2. tusky_file_create({ name: "data.json", content: "...", vaultId })
```

### Collaborate with shared vault (multi-party encrypted)
```
1. tusky_account_link_sui({ suiAddress: "0x..." })
2. tusky_vault_create({ name: "team-project", visibility: "shared" })
3. tusky_vault_grant_access({ vaultId, suiAddress: "0x..." })
4. tusky_file_upload({ filePath: "/path/to/file", vaultId })
   (any member can upload and download files)
5. tusky_vault_list_members({ vaultId })
```

---

Building your own skills

The 29 MCP tools can be composed in any order for your specific use case. Common patterns:

• Create-then-populate: create a vault or folder, then upload multiple files into it
• List-then-read: browse available data, then read specific files for context
• Write-read-write: read existing data, transform or append to it, write back
• Grant-upload-share: create a shared vault, add members, upload files that everyone can access

See the full MCP tool reference for all available operations, or explore the workflow guides below.

Workflow guides

Agent Memory Persist conversation context and retrieve it across sessions.

Project Backup Back up project directories with encrypted, durable storage.

Encrypted Artifacts Store sensitive agent outputs with end-to-end encryption.

Multi-Agent Sharing Share data between agents using public vaults.

Shared Vault Collaboration Collaborate with on-chain encrypted shared vaults.

MCP Server Full setup guide and tool reference.

CLI reference All CLI commands including the MCP server.