Skip to content
Tusky

Agent Skills

SKILL.md — ready to use

Section titled “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

Section titled “One-command install”

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

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

Terminal window
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.

Use it

Section titled “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

Section titled “What’s inside”

The SKILL.md gives your agent:

  • All 20 MCP tools — names, arguments, and when to use each one
  • 10 key rules — private vs. public vaults, encryption handling, deletion behavior, best practices
  • 4 workflow patterns — context storage, project backup, file retrieval, multi-agent data sharing

Full SKILL.md

Section titled “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)


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


- `tusky_vault_create` — Create a vault. Args: `name` (required), `description`, `visibility` ("public" or "private", 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`


### 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_delete` — Delete folder. Args: `folderId` (required)


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


## 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. **Public vaults are not encrypted** — do not store sensitive data in public vaults.
4. **Vault visibility is immutable** — you cannot change it after creation. Ask the user upfront if they want public or private.
5. **Prefer `tusky_file_create` for text content** — it's simpler than writing to disk and then uploading.
6. **Prefer `tusky_file_read` over `tusky_file_download`** when you just need to inspect content — it returns the data inline.
7. **Use `tusky_file_upload` for local files** — it handles encryption, presigned URLs, and upload confirmation automatically.
8. **Organize with folders** — for multi-file operations (backups, context storage), create a folder structure first.
9. **Files sync to Walrus automatically** — after upload, files start in `hot` status and background workers sync them to Walrus. No action needed.
10. **Deleted files go to trash** — they're restorable for 7 days. Use `tusky_trash_empty` only when the user explicitly wants permanent deletion.


## 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 })
```

Workflow recipes

Section titled “Workflow recipes”

The following recipes expand on the patterns above with detailed explanations. Use these as reference for building your own skills or understanding what the agent does.

These recipes assume you have the MCP server configured and connected to your agent.

Store conversation context

Section titled “Store conversation context”

Persist conversation summaries, decisions, and working notes so your agent can pick up where it left off across sessions.

Tools used: tusky_vault_create, tusky_folder_create, tusky_file_create, tusky_file_list, tusky_file_read

Workflow

Section titled “Workflow”

  1. Create a dedicated vault for context storage (once per project):

    tusky_vault_create({ name: "agent-context", visibility: "private" })

  2. Organize by session with folders:

    tusky_folder_create({ vaultId: "<vault-id>", name: "2025-03-16-session" })

  3. Save context as files — conversation summaries, key decisions, task state:

    tusky_file_create({
      name: "session-summary.md",
      content: "## Session Summary\n\n- Discussed migration to v2 API...",
      encoding: "utf-8",
      vaultId: "<vault-id>",
      folderId: "<folder-id>"
    })

  4. Retrieve context in future sessions by listing and reading:

    tusky_file_list({ vaultId: "<vault-id>" })
    tusky_file_read({ fileId: "<file-id>" })

When to use this

Section titled “When to use this”
  • Long-running projects where the agent needs to remember past decisions
  • Agents that operate across multiple sessions and need continuity
  • Storing structured data like task lists, architecture decisions, or meeting notes

Backup a project

Section titled “Backup a project”

Upload an entire project directory to Tusky for durable, decentralized backup. Files sync to Walrus automatically — no single point of failure.

Tools used: tusky_vault_create, tusky_folder_create, tusky_file_upload

Workflow

Section titled “Workflow”

  1. Create a vault for the backup:

    tusky_vault_create({ name: "myapp-backup-2025-03-16", visibility: "private" })

  2. Mirror the directory structure with folders:

    tusky_folder_create({ vaultId: "<vault-id>", name: "src" })
    tusky_folder_create({ vaultId: "<vault-id>", name: "tests", parentId: "<src-folder-id>" })

  3. Upload each file to the corresponding folder:

    tusky_file_upload({
      filePath: "/path/to/project/src/index.ts",
      vaultId: "<vault-id>",
      folderId: "<src-folder-id>"
    })

  4. Repeat for all files. The agent can walk the directory tree and upload in bulk.

When to use this

Section titled “When to use this”
  • Periodic backups of source code or configuration
  • Snapshotting a project before a major refactor
  • Archiving build artifacts or release bundles

Shared agent memory

Section titled “Shared agent memory”

Use a public vault to share data between multiple agents or services. Any agent with the vault ID can read files without authentication.

Tools used: tusky_vault_create, tusky_file_create, tusky_file_list, tusky_file_read

Workflow

Section titled “Workflow”

  1. Create a public vault for shared data:

    tusky_vault_create({ name: "shared-memory", visibility: "public" })

  2. Agent A writes data — research results, analysis, extracted entities:

    tusky_file_create({
      name: "research-findings.json",
      content: "{\"topic\": \"market analysis\", \"findings\": [...]}",
      encoding: "utf-8",
      vaultId: "<vault-id>"
    })

  3. Agent B reads data — picks up where Agent A left off:

    tusky_file_list({ vaultId: "<vault-id>" })
    tusky_file_read({ fileId: "<file-id>" })

When to use this

Section titled “When to use this”
  • Multi-agent pipelines where one agent produces data for another
  • Sharing reference data, lookup tables, or configuration across agents
  • Publishing analysis results for downstream consumption

Encrypted artifact storage

Section titled “Encrypted artifact storage”

Store sensitive agent outputs — API keys, credentials, private analysis, PII-containing data — in a private vault with end-to-end encryption. The server never sees the plaintext.

Tools used: tusky_vault_create, tusky_file_create, tusky_file_read

Workflow

Section titled “Workflow”

  1. Create a private vault (default visibility):

    tusky_vault_create({ name: "sensitive-artifacts" })

  2. Store sensitive content — the MCP server encrypts it automatically:

    tusky_file_create({
      name: "api-audit-results.json",
      content: "{\"exposed_keys\": [...], \"recommendations\": [...]}",
      encoding: "utf-8",
      vaultId: "<vault-id>"
    })

  3. Store binary artifacts using base64 encoding:

    tusky_file_create({
      name: "certificate.pem",
      content: "<base64-encoded-content>",
      encoding: "base64",
      vaultId: "<vault-id>"
    })

  4. Read back — decryption is transparent:

    tusky_file_read({ fileId: "<file-id>" })

When to use this

Section titled “When to use this”
  • Storing security audit results or vulnerability reports
  • Persisting credentials or certificates that agents need across sessions
  • Any data that must not be readable by the storage provider

Requirements

Section titled “Requirements”

The MCP server must have encryption unlocked. Set TUSKYDP_PASSWORD in the MCP config’s env block or run tusky encryption unlock beforehand. See the MCP server guide for details.

File retrieval and analysis

Section titled “File retrieval and analysis”

Pull files from Tusky into the agent’s context for analysis, transformation, or summarization. Useful for agents that need to read stored documents, logs, or data files as part of their reasoning.

Tools used: tusky_vault_list, tusky_file_list, tusky_folder_get_contents, tusky_file_read, tusky_file_get

Workflow

Section titled “Workflow”

  1. Browse available data — list vaults and files:

    tusky_vault_list()
    tusky_file_list({ vaultId: "<vault-id>" })

  2. Navigate folders if the data is organized hierarchically:

    tusky_folder_get_contents({ folderId: "<folder-id>" })

  3. Check file metadata before reading — size, type, status:

    tusky_file_get({ fileId: "<file-id>" })

  4. Read file content inline:

    tusky_file_read({ fileId: "<file-id>" })

    Text files are returned as text. Binary files are returned as base64. For large files, use tusky_file_download to save to disk first.

  5. Use the content in agent reasoning — summarize documents, extract data, answer questions based on stored files.

When to use this

Section titled “When to use this”
  • Agents that need to reference stored documentation or specifications
  • Pulling in logs or data files for analysis
  • Building context from previously stored conversation summaries (see Store conversation context)
  • Answering user questions based on files stored in Tusky

Building your own skills

Section titled “Building your own skills”

These recipes are starting points. The 20 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

See the full MCP tool reference for all available operations.

MCP Server Full setup guide and tool reference.
CLI reference All CLI commands including the MCP server.