Skip to content
Back to search

tensorlake-skills

Coding agent skill for Tensorlake. Routes Claude Code, OpenAI Codex, and other AI agents to live Tensorlake docs for sandboxes, orchestration, and SDK usage.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/tensorlakeai--tensorlake-skills/badge.svg)](/listings/tensorlakeai--tensorlake-skills)

HTML

<a href="/listings/tensorlakeai--tensorlake-skills"><img src="/api/listings/tensorlakeai--tensorlake-skills/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Quick Install

Any Agent

npx skills add tensorlakeai/tensorlake-skills

Works with Claude Code, Cursor, Cline, GitHub Copilot, Windsurf, and more via [skills.sh](https://skills.sh).

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 9 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. {
  2. "plugins": [
  3. {
  4. "name": "tensorlake",
  5. "description": "Tensorlake SDK for agent sandboxes and sandbox-native orchestration. Use when building AI agents that need sandboxed execution environments, isolated tool calls, or durable workflow orchestration.",
  6. "path": "."
  7. }
  8. ]
  9. }
README.md · README · 254 lines · 1 finding marked

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # Tensorlake Skill
  2. **Up-to-date Tensorlake knowledge for AI coding agents.** A lightweight skill that teaches Claude Code, OpenAI Codex, Google ADK, and other coding agents how to write correct Tensorlake code — by routing them to live documentation at [docs.tensorlake.ai](https://docs.tensorlake.ai)
  3. ## Why This Exists
  4. AI coding agents hallucinate Tensorlake APIs. Their training data don't have the knowledge, so they invent function signatures, miss new features, and reference removed endpoints. This skill fixes that: when an agent detects a Tensorlake-related task, it fetches the live docs and uses them as the source of truth.
  5. It covers the **Python SDK** (`pip install tensorlake`), **TypeScript SDK** (`npm install tensorlake`), and **CLI** (`curl -fsSL https://tensorlake.ai/install | sh`).
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 9 on GitHub
  6. ## What is a "skill"?
  7. A skill is a small markdown instruction file that teaches an AI coding agent how to use a specific tool or library — similar in spirit to an MCP server, but lighter weight and model-agnostic. The agent reads the skill on activation, follows its instructions (e.g., "fetch live docs before writing code"), and applies the result to your task. No server to run, no extra runtime — just a file the agent reads.
  8. ## Example
  9. Without the skill:
  10. > **User:** Build me a Tensorlake sandbox that runs untrusted Python and exposes port 8000.
  11. > **Agent:** *(writes code referencing `Sandbox.new()` — an API that doesn't exist in current SDK)*
  12. With the skill:
  13. > **User:** Build me a Tensorlake sandbox that runs untrusted Python and exposes port 8000.
  14. > **Agent:** *(skill triggers → fetches `https://docs.tensorlake.ai/llms.txt` → loads `sandboxes/lifecycle.md` → writes correct code using current `tensorlake.Sandbox.create()` API)*
  15. ## What This Skill Does
  16. When it triggers, the skill instructs the agent to:
  17. 1. Verify the SDK is installed and `TENSORLAKE_API_KEY` is configured.
  18. 2. `WebFetch https://docs.tensorlake.ai/llms.txt` to get the current doc index.
  19. 3. From that index, fetch the `.md` page(s) relevant to the task and use them as the source of truth.
  20. 4. Only on fetch failure, fall back to [`references/feature_lookup.md`](references/feature_lookup.md), which routes features and keywords to a bundled snapshot.
  21. It also enforces a few guardrails: verify every symbol against the live docs or installed package before suggesting code, prefer live docs over snapshots when they disagree, and never request, embed, or print API keys.
  22. ## When It Triggers
  23. The skill activates when the user mentions Tensorlake or sandboxes, or asks the agent to do anything that maps to the Tensorlake product surface — for example:
  24. - Run LLM-generated or untrusted code in an isolated sandbox
  25. - Persist a sandbox across sessions via suspend/resume, or fork from a snapshot
  26. - Build a custom sandbox image, expose a port, or configure egress allowlists
  27. - Fan out parallel sandboxes from Python with the **async SDK** (`AsyncSandbox` + `asyncio.gather`)
  28. - Open **local tunnels** to a sandbox for non-HTTP protocols (VNC, Postgres, Redis, custom binary)
  29. - Drive **Chrome over CDP** with Playwright or `chrome-devtools-mcp` (browser automation, scraping)
  30. - Drive PTY/interactive shells or computer-use / desktop automation
  31. - **SSH** into a sandbox, transfer files via `scp`/`sftp`/`rsync`, or set up port forwarding (`-L` / `-D` / `-R`)
  32. - Use a named sandbox as a **remote dev environment** (VS Code Remote-SSH, JetBrains Gateway, Cursor) with idle-suspend and resume-by-name
  33. - Build sandbox images from **OCI base images** (`python:3.12-slim`, `node:22-alpine`, `ghcr.io/...`) in addition to `tensorlake/*` bases
  34. - Run **Harbor** evaluations (Terminal-Bench, SWE-Bench, Aider Polyglot) or RL rollouts in per-trial sandboxes
  35. - Bundle agent skills (Claude Code, Codex, Cursor, Cline, Windsurf, Copilot, Google ADK) inside a sandbox image
  36. - Build durable workflows or multi-agent orchestration with the Applications SDK
  37. - Ask questions about Tensorlake APIs or documentation
  38. It works alongside any LLM provider (OpenAI, Anthropic) and any agent framework (Claude Agents SDK, OpenAI Agents SDK, LangChain, etc.) — Tensorlake is the infrastructure layer.
  39. ## Supported Agents
  40. | Agent | File | How to Install |
  41. | ------------------------------------------------------------- | ----------- | ----------------------------- |
  42. | [Claude Code](https://docs.anthropic.com/en/docs/claude-code) | `SKILL.md` | See [Quick Install](#quick-install) |
  43. | [Google ADK](https://google.github.io/adk-docs/skills/) | `SKILL.md` | See [Quick Install](#quick-install) |
  44. | [OpenAI Codex](https://openai.com/index/codex/) | `AGENTS.md` | See [Quick Install](#quick-install) |
  45. ## Installation
  46. ### Quick Install
  47. #### Any Agent
  48. ```bash
  49. npx skills add tensorlakeai/tensorlake-skills
  50. ```
  51. Works with Claude Code, Cursor, Cline, GitHub Copilot, Windsurf, and more via [skills.sh](https://skills.sh).
  52. ## Setup
  53. Tensorlake requires a `TENSORLAKE_API_KEY` configured in the local environment. Get one at [cloud.tensorlake.ai](https://cloud.tensorlake.ai), then either run `tl login` (or `tensorlake login`) / `npx tl login` (TypeScript) or configure the variable through your shell profile, `.env` file, or secret manager. Do not paste API keys into chat, commit them to source control, or print them in terminal output.
  54. ## Repository Structure
  55. ```
  56. tensorlake-skills/
  57. ├── SKILL.md # Skill definition (Claude Code, Google ADK)
  58. ├── AGENTS.md # Skill definition (OpenAI Codex)
  59. ├── CLAUDE.md # Repo governance (sync rules, version bump policy)
  60. ├── CHANGELOG.md # Changes tracked per SDK version
  61. ├── .claude-plugin/
  62. │ ├── plugin.json # Claude Code plugin metadata
  63. │ └── marketplace.json # Marketplace listing
  64. ├── scripts/
  65. │ └── bump-version.sh # Version bump automation
  66. ├── .github/
  67. │ ├── workflows/
  68. │ │ ├── sync-check.yml # Weekly drift detection (CI)
  69. │ │ └── evals.yml # PR eval CI (skill-trigger + judge-graded)
  70. │ └── scripts/
  71. │ ├── fetch_docs.py # Fetch live doc pages
  72. │ ├── check_drift.py # Compare fetched vs bundled
  73. │ └── sources.yaml # Map: reference file → source URLs
  74. ├── evals/
  75. │ ├── evals.json # Eval suite: prompts, expected references, judge criteria
  76. │ ├── run.py # Run evals (claude -p with stream-json + trigger detection)
  77. │ ├── grade.py # Judge-LLM grading (skipped when skill didn't trigger)
  78. │ ├── grade_static.py # Static / non-judge grading checks
  79. │ ├── filter.py # Map changed references/** files → impacted eval IDs
  80. │ └── ci_summary.py # Render PR summary table (trigger rate + pass/fail)
  81. └── references/
  82. ├── feature_lookup.md # Curated index — routes features/keywords to the snapshot below
  83. ├── applications_sdk.md # Orchestration API reference
  84. ├── sandbox_sdk.md # Sandbox API reference
  85. ├── sandbox_persistence.md # Sandbox state: snapshots, suspend/resume, state machine
  86. ├── computer_use.md # Desktop automation: XFCE + Firefox, screenshots, mouse/keyboard, noVNC
  87. ├── volumes_and_git.md # Cloud Volumes (tl fs) and managed Git repositories (tl git)
  88. ├── platform.md # Auth, access control, lifecycle webhooks, EU endpoints, security, SSO
  89. ├── sandbox_usecases.md # Skills-in-sandboxes, tool calls, agent integrations, evals, CI/CD
  90. └── troubleshooting.md # Common issues, sandbox pitfalls, agent patterns, runtime architecture
  91. ```
  92. ## Versioning
  93. This skill uses [SemVer](https://semver.org/) for its own version, independent of the TensorLake SDK version it documents.
  94. - **Major** — breaking changes (renamed/removed reference files, restructured skill)
  95. - **Minor** — new reference files, significant content additions, new SDK version coverage
  96. - **Patch** — fixes, small content updates, drift corrections
  97. The TensorLake SDK version being documented is tracked separately in `sources.yaml` and in the source headers at the top of each reference file.
  98. ### Bumping the Version
  99. Use `scripts/bump-version.sh` to update the version across all files:
  100. ```bash
  101. ./scripts/bump-version.sh patch # 2.0.0 -> 2.0.1
  102. ./scripts/bump-version.sh minor # 2.0.0 -> 2.1.0
  103. ./scripts/bump-version.sh major # 2.0.0 -> 3.0.0
  104. ./scripts/bump-version.sh minor --sdk 0.5.0 # bump + update SDK version in changelog
  105. ```
  106. The script:
  107. 1. Reads the current version from `SKILL.md` frontmatter
  108. 2. Bumps major, minor, or patch
  109. 3. Updates `SKILL.md` and `AGENTS.md`
  110. 4. Stamps the `[Unreleased]` section in `CHANGELOG.md` with the new version and today's date
  111. 5. Prints the git commands to commit and tag
  112. ### Release Workflow
  113. ```bash
  114. # 1. Make your changes to reference files, SKILL.md, etc.
  115. # 2. Add an [Unreleased] section to CHANGELOG.md with your changes
  116. # 3. Run the bump script
  117. ./scripts/bump-version.sh minor
  118. # 4. Commit, tag, and push
  119. git add -A
  120. git commit -m "release: v2.1.0"
  121. git tag v2.1.0
  122. git push origin HEAD && git push origin v2.1.0
  123. ```
  124. ## Maintaining References
  125. ### Source Tracking
  126. Each reference file has a source header that tracks which doc pages it was built from:
  127. ```html
  128. <!--
  129. Source:
  130. - https://docs.tensorlake.ai/sandboxes/lifecycle.md
  131. - https://docs.tensorlake.ai/sandboxes/commands.md
  132. SDK version: tensorlake 0.5.44
  133. Last verified: 2026-06-16
  134. -->
  135. ```
  136. The full mapping is in `.github/scripts/sources.yaml`.
  137. ### Drift Detection
  138. A weekly GitHub Action (`sync-check.yml`) fetches the live TensorLake docs and compares them against the bundled reference files. If new APIs, removed endpoints, or changed signatures are detected, it opens a GitHub Issue with a summary of what drifted.
  139. ### Eval Suite
  140. The `evals/` directory contains a test harness that runs the skill end-to-end on representative prompts and grades the responses. CI (`.github/workflows/evals.yml`) runs it automatically on PRs that touch `references/**.md`; version bumps, `SKILL.md` / `AGENTS.md` edits, and `evals/**` script changes don't auto-trigger (use `workflow_dispatch` to run on-demand, optionally with a comma-separated list of eval IDs).
  141. Each run captures two signals:
  142. - **Skill-trigger rate** — did the skill actually fire? Surfaced separately so a "skill didn't fire" failure doesn't masquerade as a "skill fired but answered wrong" failure. Detected from `claude -p`'s `--output-format stream-json` output.
  143. - **Judge-graded pass/fail** — an LLM judge evaluates each response against per-eval expected references and criteria. If the skill didn't trigger, judging is skipped and all expectations record `skill not triggered; grading skipped`.
  144. `evals/filter.py` maps changed reference files to impacted eval IDs (so PRs only run the evals their changes can affect). PR runs render a summary table to the GitHub Step Summary via `evals/ci_summary.py` and upload the full eval workspace as an artifact. Evals are report-only — failures show in the table but never block the PR.
  145. ### Maintenance Cadence
  146. | Frequency | Action |
  147. |-----------|--------|
  148. | Weekly (automated) | CI drift-check runs, opens issue if divergence detected |
  149. | Per SDK release | Manual update of reference files + bump version |
  150. | Monthly | Review gap coverage — are new doc pages appearing that need a new reference file? |
  151. ## FAQ
  152. ### How is this different from just pointing agents at `llms.txt` directly?
  153. `llms.txt` is the doc index. This skill adds the trigger logic ("when should the agent reach for Tensorlake docs at all?"), the fetch-and-fallback flow, guardrails (don't print API keys, verify symbols against installed packages), and an offline snapshot for when the network is unreachable. It's the difference between "here are the docs" and "here's how an agent should behave when a task involves Tensorlake."
  154. ### How does this compare to an MCP server?
  155. MCP servers are runtime processes that expose tools to an agent over a protocol. Skills are static markdown files the agent reads. Tradeoffs:
  156. - **MCP** is better when you need live state, authenticated API calls, or tool-use semantics (e.g., "list my running sandboxes").
  157. - **Skills** are better for teaching an agent *how to write code* against an SDK — no server to run, works in any agent that supports skills, zero runtime overhead.
  158. The two are complementary. You can use both.
  159. ### Does this work with models other than Claude?
  160. Yes. The skill is model-agnostic — it's a markdown instruction file. It works with Claude Code, OpenAI Codex (via `AGENTS.md`), Google ADK, Cursor, Cline, GitHub Copilot, and Windsurf. The underlying Tensorlake SDK works with any LLM provider (OpenAI, Anthropic, open models) and any agent framework.
  161. ### Do I need a Tensorlake API key to install the skill?
  162. No — installing the skill is just adding a file. You'll need a `TENSORLAKE_API_KEY` when the agent actually runs Tensorlake code on your behalf. Get one at [cloud.tensorlake.ai](https://cloud.tensorlake.ai).
  163. ### What happens if `docs.tensorlake.ai` is unreachable?
  164. The skill falls back to bundled snapshots in `references/`. They lag the live docs (intentionally — they're not the source of truth) but cover the major API surface: sandboxes, applications/orchestration, persistence, Cloud Volumes and Git repositories, computer use, and platform features.
  165. ### How often is this updated?
  166. A weekly CI job diffs the bundled snapshots against live docs and opens an issue if they've drifted. Reference files are refreshed per SDK release. The live docs are always current — the skill just routes to them.
  167. ## Documentation
  168. - [Tensorlake Docs](https://docs.tensorlake.ai)
  169. - [LLM-friendly docs](https://docs.tensorlake.ai/llms.txt)
  170. - [API Reference](https://docs.tensorlake.ai/api-reference/v2/introduction)
  171. ## License
  172. MIT

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.