Skills

A skill is a focused set of instructions for a job. A skill registry groups related skills so an agent can discover short summaries first and load the full instructions only when needed. Skills and registries can be workspace-owned or personal. Each has independent visibility and ownership modes. Visibility controls discovery, package inspection, and reading skill content. Ownership controls root settings, registry membership, grants, and deletion. Set a plane to Private and grant a same-tenant Identity user or group when sharing should be narrower than the workspace. Ownership and administrator access do not imply visibility. Packages inherit their skill, while registry discovery tools and membership views inherit the registry. A personal registry may include personal skills owned by that same user, while a workspace registry cannot widen access by including a personal skill. Tilde synchronizes trusted upstream skill providers from official GitHub repositories. The built-in sources include Cursor’s first-party plugins and canvases, Notion, Granola, Parallel, Superpowers, Browserbase, Apollo, Zoom, Stripe, Neon, Vercel, AWS, Anthropic, Microsoft, Cloudflare, and YC Software QM’s portable general-purpose design skills where those projects publish valid SKILL.md files. Monorepo sources are path-scoped so unrelated third-party plugins and QM runtime-specific skills are not imported. Each synchronization is tied to an upstream commit. Tilde stores the complete bounded skill package, not only SKILL.md: package-local references, templates, scripts, examples, and media are retained with their relative paths and media types. Unsafe paths and symbolic links are rejected, and a partial upstream fetch never replaces the previous successful snapshot. Skills removed or renamed upstream are removed from the provider catalog on the next complete sync, while team-owned copies and registry membership remain explicit Tilde resources. Portable state embeds the selected package files with content checksums. Import verifies every file before recreating the package in the target workspace, so referenced assets remain available without relying on the original provider being reachable during import.

Use package assets

Call GET /api/v1/team/{team_id}/skill/{skill_id}/package to inspect the immutable package manifest and its entrypoint, paths, media types, sizes, checksums, executable flags, and Git provenance. To retrieve one referenced file, call POST /api/v1/team/{team_id}/skill/{skill_id}/package/download with its exact manifest path. Tilde returns a short-lived download URL; use the manifest checksum when persisting or executing downloaded content. For example, suppose the manifest lists a Python helper at examples/analyze.py:

API_BASE="https://api.trytilde.ai/api/v1"

MANIFEST=$(curl --fail --silent --show-error \
  -H "x-api-key: $TILDE_API_KEY" \
  "$API_BASE/team/$TILDE_TEAM_ID/skill/$TILDE_SKILL_ID/package")

PYTHON_PATH=$(printf '%s' "$MANIFEST" | \
  jq -r '.files[] | select(.path == "examples/analyze.py") | .path')
PYTHON_SHA256=$(printf '%s' "$MANIFEST" | \
  jq -r '.files[] | select(.path == "examples/analyze.py") | .checksum_sha256')

DOWNLOAD_URL=$(curl --fail --silent --show-error \
  -X POST \
  -H "x-api-key: $TILDE_API_KEY" \
  -H "content-type: application/json" \
  --data "$(jq -n --arg path "$PYTHON_PATH" '{path: $path}')" \
  "$API_BASE/team/$TILDE_TEAM_ID/skill/$TILDE_SKILL_ID/package/download" | \
  jq -r '.url')

curl --fail --silent --show-error "$DOWNLOAD_URL" -o /tmp/analyze.py
printf '%s  %s\n' "$PYTHON_SHA256" /tmp/analyze.py | sha256sum --check
sed -n '1,160p' /tmp/analyze.py
python3 /tmp/analyze.py

Set TILDE_TEAM_ID and TILDE_SKILL_ID to the workspace and skill identifiers. The first request reads the manifest, the second asks Tilde for a short-lived URL for that exact file, and the final commands inspect and run the downloaded example.

Create a skill registry

Create the registry

Open Tilde, select your workspace, and go to Skills → Registries. Create a registry with a clear name and description.

Add skills

Add trusted upstream skills from a configured provider or create a team-owned skill. Keep each registry focused on one agent or workflow.

Enable discovery tools

When you create a registry, Tilde also creates and enables a private tool provider bound to it. Go to Tools → Manage Enabled Tools and find the provider named after your registry.It exposes four tools:

list_skills lists the skills in the registry.
search_skills returns relevant skill summaries.
read_skill_description reads one description before loading its instructions.
read_skill loads the complete skill.

Expose the tools to your agent

Go to Tools → MCP Servers and open the server used by your agent. Add the registry’s four discovery tools.Tell the agent to search first, inspect the description, and read the complete skill only when it is relevant. This keeps large instruction files out of its context until they are useful.

Access skills programmatically

Every signed chatKitEndpoint handler receives a typed context.skills client. Use it when your application already knows which registry and skill to load. Use the MCP discovery tools when the model should choose a skill itself.

app/api/agent/route.ts

import { openai } from "@ai-sdk/openai";
import {
  chatKitEndpoint,
  convertToAiSdkMessages,
  createClient,
} from "@trytilde/sdk-vercel-ai-node";
import { consumeStream, convertToModelMessages, streamText } from "ai";

const tilde = createClient({
  apiKey: process.env.TILDE_API_KEY!,
  orgId: process.env.TILDE_ORG_ID!,
  teamId: process.env.TILDE_TEAM_ID!,
});

export const POST = chatKitEndpoint({
  client: tilde,
  webhookSigningKey: process.env.TILDE_WEBHOOK_SIGNING_KEY!,
  async handler(request, context) {
    const registry = await context.skills.registry(
      process.env.TILDE_SKILL_REGISTRY_ID!,
    );
    const availableSkills = await registry.list();
    const skill = await registry.find("pull-request-review");

    console.log(availableSkills.map(({ name, description }) => ({ name, description })));

    const history = await context.session.history();
    const messages = await convertToAiSdkMessages({
      messages: [...history.items, ...context.messages],
      chatkit: context.chatkit,
    });
    const result = streamText({
      abortSignal: request.signal,
      messages: await convertToModelMessages(messages),
      model: openai("gpt-5.5"),
      system: skill.content,
    });

    return result.toUIMessageStreamResponse({
      consumeSseStream: consumeStream,
      originalMessages: messages,
    });
  },
});

Set TILDE_SKILL_REGISTRY_ID to the registry ID shown in Tilde. registry.find() accepts a skill ID or its stable name.

Get started

Identities

Product features

Guides

Use package assets

Create a skill registry

Access skills programmatically

​Use package assets

​Create a skill registry

​Access skills programmatically

Use package assets

Create a skill registry

Access skills programmatically