Tessl

https://docs.tessl.io/
Admin
Tessl is a platform for managing context for coding agents, providing a package manager for agent...
Tokens:43,701
Snippets:419
Trust Score:8.6
Update:7 months ago
Show doc for...
Tokens:
Raw
### Manage Tessl Dependencies and Skills

Source: https://docs.tessl.io/introduction-to-tessl/quickstart-skills-docs-rules

Commands to search for library documentation and install pre-defined skills to enhance agent workflows.

```bash
tessl search express
```

```bash
tessl install tessl-labs/quickstart-debug-api-endpoints
```

--------------------------------

### MCP Configuration Example (TOML)

Source: https://docs.tessl.io/reference/custom-agent-setup

This TOML snippet shows an alternative way to configure Tessl MCP servers, specifying the type, command, and arguments for the Tessl service.

```toml
[mcp_servers.tessl]
type = "stdio"
command = "tessl"
args = ["mcp", "start"]
```

--------------------------------

### Manually Search and Install a Tile

Source: https://docs.tessl.io/use/make-your-agents-smarter-with-documentation

You can manually search for and install tiles from the Tessl Registry using the CLI. This example shows how to search for and install a tile for the FastAPI library.

```bash
tessl search/install
```

--------------------------------

### Initialize Tessl Project

Source: https://docs.tessl.io/introduction-to-tessl/quickstart-skills-docs-rules

Creates a new directory and initializes a Tessl project, generating a tessl.json manifest file for agent context configuration.

```bash
mkdir tessl-demo
cd tessl-demo
tessl init
```

--------------------------------

### Tessl Project Configuration (tessl.json) Example

Source: https://docs.tessl.io/use/make-your-agents-smarter-with-documentation

The `tessl.json` file at the root of your project tracks installed Tessl tiles. It lists the dependencies, including their versions, that have been installed for the project.

```json
{
  "name": "my-project",
  "dependencies": {
    "tessl/pypi-fastapi": {
      "version": "0.116.0"
    }
  }
}
```

--------------------------------

### MCP Configuration Example (JSON)

Source: https://docs.tessl.io/reference/custom-agent-setup

This JSON snippet demonstrates how to configure Tessl MCP servers within an agent's settings. It specifies the command to execute and its arguments.

```json
{
  "mcpServers": {
    "tessl": {
      "command": "tessl",
      "args": [
        "mcp",
        "start"
      ]
    }
  }
}
```

--------------------------------

### Install Tessl Model Performance Review Skill

Source: https://docs.tessl.io/evaluate/evaluate-skill-quality-using-scenarios

Installs the `review-model-performance` skill from the Tessl registry. This skill simplifies the process of benchmarking evaluations across different Claude models (Haiku, Sonnet, Opus) by providing guided flows and automatic comparisons.

```bash
tessl install tessl-labs/review-model-performance
```

--------------------------------

### Tessl Eval Compare Examples

Source: https://docs.tessl.io/reference/cli-commands

Provides examples for comparing evaluation results using the Tessl CLI. Demonstrates basic comparison for a batch of scenarios and how to display a detailed breakdown for each scenario.

```shell
# Compare results for a batch
tessl eval compare ./evals/
```

```shell
# Show per-scenario breakdown
tessl eval compare ./evals/ --breakdown
```

--------------------------------

### Install Tessl Tiles

Source: https://docs.tessl.io/reference/cli-commands

Installs versioned bundles of reusable context (tiles) into your project. Tiles can include skills, documentation, and rules. Supports installation from registry, GitHub, or local file paths. Options include installing project dependencies, globally, selecting specific skills, and watching local files for changes.

```shell
tessl install [--project-dependencies] [--global] [--skill <value>]... [--yes] [--verbose] [--watch-local] <source>...
```

--------------------------------

### Authenticate and Manage Tessl CLI Session

Source: https://docs.tessl.io/introduction-to-tessl/installation

Commands to verify installation, authenticate the user session, and manage login state. Use 'tessl login' to start the device-based authentication flow.

```shell-session
tessl --help
tessl login
tessl whoami
tessl logout
```

--------------------------------

### Example SKILL.md Structure

Source: https://docs.tessl.io/create/creating-skills

An example of a SKILL.md file, which defines a skill's metadata (name, description) in YAML frontmatter and provides detailed instructions and examples in Markdown.

```markdown
---
name: database-migration-helper
description: When you need to create and manage database migrations.
---

# Database Migration Helper

## Creating a Migration

When creating a new migration:

1. Always include both `up` and `down` migrations
2. Use transactions when possible
3. Test migrations on a copy of production data first

### Example: Adding a Column

    -- Up migration
    ALTER TABLE users ADD COLUMN email_verified BOOLEAN DEFAULT FALSE;

    -- Down migration
    ALTER TABLE users DROP COLUMN email_verified;


## Best Practices

* Never modify existing migrations that have been applied to production
* Always test rollbacks
* Keep migrations small and focused

```

--------------------------------

### tessl install

Source: https://docs.tessl.io/reference/cli-commands

Installs tiles (versioned bundles of reusable agent context including skills, documentation, and rules) into your project. Supports installation from the registry, GitHub repositories, and local file paths.

```APIDOC
## tessl install

### Description
Install tiles into your project. Tiles are versioned bundles of reusable, agent-agnostic context that make coding agents more effective. They can contain skills, documentation, and rules.

### Method
CLI Command

### Endpoint
N/A (CLI Command)

### Parameters
#### Arguments
* `source` (string, required): Tile or GitHub URL to install. Can be:
  * Registry tile: `workspace/tile[@version]` (version optional, defaults to latest)
  * GitHub repository:
    * Full URL: `https://github.com/owner/repo`
    * Shorthand: `github:owner/repo` (e.g., `github:softaworks/agent-toolkit`)
  * File path: `file:<path>` to install from local directory

#### Flags
* `--project-dependencies` (boolean, optional): Scan project dependencies and install matching tiles (interactive). Dependencies should be installed locally via package manager prior to using this. When used in a monorepo, scans dependencies from the current working directory.
* `--global` / `-g` (boolean, optional): Install tiles globally to `~/.tessl/` instead of the current project. Global tiles are available across all your projects.
* `--skill` (string, repeatable, optional): Select specific skills to install from GitHub repositories. Used when a repository contains multiple skills. If omitted, you'll be prompted interactively to select from available skills. Can be specified multiple times to install multiple skills from the same repository.
* `--yes` (boolean, optional): Skip confirmation prompts and auto-select all skills
* `--verbose` / `-v` (boolean, optional): Show detailed warning messages during installation
* `--watch-local` (boolean, optional): Watch local file-source tiles and reinstall on changes

### Request Example
```sh
# Install a specific tile from registry
tessl install tessl/svelte@5.38.0

# Install multiple tiles from registry
tessl install tessl/svelte tessl/react

# Install tiles for all project dependencies
tessl install --project-dependencies

# Install from file system (tile.json is expected in the specified path)
tessl install file:<path to tile>

# Install from GitHub repository with interactive skill selection
tessl install https://github.com/anthropics/skills

# Install using GitHub shorthand syntax
tessl install github:softaworks/agent-toolkit

# Install specific skill by name from GitHub repository (when repo has multiple skills)
tessl install https://github.com/anthropics/skills --skill pdf

# Install multiple skills by name from GitHub repository using shorthand
tessl install github:anthropics/skills --skill pdf --skill pptx

# Install from specific branch and path in GitHub repository
tessl install https://github.com/anthropics/skills/tree/main/skills/pdf

# Monorepo workflow: Initialize at root, then install dependencies from subfolder
tessl init
cd backend
tessl install --project-dependencies

# Install a tile globally (available across all projects)
tessl install --global tessl/svelte
```

### Response
#### Success Response
Tiles are installed to `.tessl/tiles/<workspace>/<tile>/` in your project (or `~/.tessl/tiles/` when using `--global`). Your project's `tessl.json` is automatically updated with the tile reference. If a tile is already installed and up-to-date, it will be skipped.

#### Response Example
N/A (CLI Output)
```

--------------------------------

### Tessl Rules Setup (Markdown)

Source: https://docs.tessl.io/reference/custom-agent-setup/opencode

Specifies the path to the Tessl rules file. This markdown entry is used to inform Tessl where to find the rules for processing. Ensure the path '.tessl/RULES.md' is correct relative to your project's root directory.

```markdown
@.tessl/RULES.md
```

--------------------------------

### Troubleshoot Installation and MCP Server

Source: https://docs.tessl.io/support/troubleshooting

Commands for initializing projects, installing skills with verbose logging, and managing the MCP server.

```bash
tessl init
tessl install <skill> -v
tessl install --project-dependencies
tessl skill search <skill> -v
tessl mcp start
```

--------------------------------

### Initialize Tessl Project

Source: https://docs.tessl.io/use/make-your-agents-smarter-with-documentation

The `tessl init` command initializes Tessl in your project, adding necessary files, configuring agents, and automatically installing tiles for project dependencies. It also helps set up local agents when cloning a repository.

```bash
tessl init
```

--------------------------------

### Install API

Source: https://docs.tessl.io/reference/mcp-tools

Installs tiles into your project. You can install a specific tile or sync all missing tiles defined in tessl.json. Authentication is handled automatically.

```APIDOC
## POST /install

### Description
Installs tiles into your project. Can install a specific tile or sync all missing tiles from tessl.json. Authentication is required and handled automatically.

### Method
POST

### Endpoint
/install

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **packageName** (string) - Optional - Tile name to install (e.g., "workspace/tile" or "workspace/tile@version"). If not provided, installs all missing tiles from tessl.json.
- **projectDir** (string) - Optional - Project directory. Defaults to current working directory.

### Request Example: Install specific tile
```json
{
  "packageName": "tessl/svelte@5.38.0"
}
```

### Request Example: Sync all missing tiles
```json
{
  "projectDir": "/path/to/your/project"
}
```

### Response
#### Success Response (200)
- **message** (string) - Confirmation of installation or sync.

#### Response Example
```json
{
  "message": "Tiles installed successfully."
}
```
```

--------------------------------

### Install Tessl CLI

Source: https://docs.tessl.io/introduction-to-tessl/installation

Commands to install the Tessl CLI using various package managers. Choose the method appropriate for your environment.

```bash
curl -fsSL https://get.tessl.io | sh
```

```bash
brew install tesslio/tap/tessl
```

```bash
npm install -g @tessl/cli
```

--------------------------------

### Install Tiles for Project Dependencies

Source: https://docs.tessl.io/use/make-your-agents-smarter-with-documentation

Use `tessl install --project-dependencies` to automatically install Tessl tiles for new or updated project dependencies. This is useful when dependencies are added manually.

```bash
tessl install --project-dependencies
```

--------------------------------

### Install Tessl Tile Locally from Filesystem (Bash)

Source: https://docs.tessl.io/create/developing-tiles-locally

Installs a Tessl tile directly from a local filesystem path. This allows for immediate testing and iteration without publishing to a registry.

```bash
tessl install file:./my-tile
```

--------------------------------

### Agent Rules Configuration (Markdown)

Source: https://docs.tessl.io/reference/custom-agent-setup

This markdown snippet shows how to configure agent rules to utilize Tessl MCP and other installed tile rules. It references a specific Tessl rules file.

```markdown
# Agent Rules

@.tessl/RULES.md
```

--------------------------------

### Install Skill from Tessl Registry

Source: https://docs.tessl.io/create/creating-skills

Installs a published skill into the current project. The skill is downloaded as part of a Tessl package and made available to the configured agent. A specific version can be installed using the '@' symbol.

```shell
tessl install myworkspace/my-skill
```

```shell
tessl install myworkspace/my-skill@1.0.0
```

--------------------------------

### Install Tile into Project

Source: https://docs.tessl.io/reference/mcp-tools

Installs a specific tile or synchronizes all missing tiles from tessl.json into the project. Authentication is required and handled automatically. Tiles are installed to `.tessl/tiles/` and `tessl.json` is updated. If no version is specified, the latest version is installed.

```json
{
  "packageName": "tessl/svelte@5.38.0"
}
```

```json
{}
```

--------------------------------

### Tessl Eval Run Examples

Source: https://docs.tessl.io/reference/cli-commands

Illustrates various ways to execute Tessl evaluations using the CLI, including running evaluations in the current directory, for specific tiles, forcing re-runs, using multiple agents, testing historical context, overriding context patterns, labeling runs, and specifying variants.

```shell
# Run codebase evals in current directory (auto-detects defaults)
tessl eval run ./evals/
```

```shell
# Run tile evals for a specific tile
tessl eval run ./my-tile
```

```shell
# Force re-run all evals
tessl eval run --force ./my-tile
```

```shell
# Run with multiple agents
tessl eval run ./evals/ --agent=claude:claude-sonnet-4-6 --agent=cursor:auto
```

```shell
# Test updated context against historical scenarios
tessl eval run ./evals/ --context-ref=HEAD
```

```shell
# Override context pattern at run time
tessl eval run ./evals/ --context-pattern="**/*.knowledge.mdc"
```

```shell
# Label a run for easier identification later
tessl eval run ./my-tile --label "testing claude-opus-4-6"
```

```shell
# Run only the baseline variant (no context files injected)
tessl eval run ./evals/ --variant without-context
```

--------------------------------

### Install Tessl Eval Skills

Source: https://docs.tessl.io/evaluate/evaluating-your-codebase

Installs the 'eval-setup', 'eval-improve', and 'scenarios-review' Tessl skills. These skills automate the process of setting up evaluations, improving agent performance, and reviewing scenario suites.

```shell
tessl install tessl-labs/eval-setup
tessl install tessl-labs/eval-improve
tessl install tessl-labs/scenarios-review
```

--------------------------------

### Example tile.json Manifest

Source: https://docs.tessl.io/create/creating-skills

The tile.json file serves as the package manifest for a Tessl skill, containing metadata such as the package name, version, summary, and the mapping of skill names to their respective SKILL.md files.

```json
{
  "name": "myworkspace/database-migration-helper",
  "version": "1.0.0",
  "summary": "Helper for creating and managing database migrations",
  "private": true,
  "skills": {
    "database-migration-helper": {
      "path": "SKILL.md"
    }
  }
}

```

--------------------------------

### Install and Search Tiles via Tessl CLI

Source: https://docs.tessl.io/distribute/distributing-via-registry

Commands to search for available tiles and install specific versions of tiles into local projects.

```bash
tessl install myworkspace/your-tile
tessl search your-tile
tessl install myworkspace/your-tile@1.0.0
```

--------------------------------

### Tessl CLI Command for Installing Tiles

Source: https://docs.tessl.io/create/creating-documentation

This command allows users to update to a new version of a published tile within their workspace. It fetches the latest version from the specified workspace.

```bash
tessl install myworkspace/util-formatter
```

--------------------------------

### Manage Tessl configuration settings

Source: https://docs.tessl.io/reference/cli-commands

Commands to get, set, list, and append values to the Tessl configuration. Supports both scalar values and array-based configuration keys.

```shell
tessl config get analytics.enabled
tessl config set analytics.enabled false
tessl config add agents cursor claude-code
tessl config list
```

--------------------------------

### Query Library Documentation with AI

Source: https://docs.tessl.io/reference/mcp-tools

Gathers documentation context from installed tiles using AI-powered search. This requires tiles to be installed first. The tool uses AI to find relevant documentation files and extracts content chunks based on the provided query.

```json
{
  "query": "How do I create a reactive store in Svelte?"
}
```

--------------------------------

### Start Tessl MCP Server

Source: https://docs.tessl.io/reference/mcp-tools

Starts the Tessl MCP server, which operates using the stdio protocol and is named 'Tessl Registry MCP'. This server facilitates AI coding agent access to the Tessl registry.

```sh
tessl mcp start
```

--------------------------------

### Setup GitHub Action for Tessl Skill Publishing

Source: https://docs.tessl.io/distribute/promote-or-claim-a-skill-you-have-created

This GitHub Actions workflow automates the publishing of Tessl skills. It checks out the repository and uses the 'tesslio/publish' action to deploy the skill. Ensure you have set up the TESSL_API_TOKEN secret in your GitHub repository.

```yaml
name: Publish Tile

permissions:
  id-token: write # Required for OIDC token
  contents: read # Required to checkout the repository

on:
  push:
    branches:
    - main # Trigger on push / merge to main

jobs:
  publish:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v6
    - uses: tesslio/publish@main
    with:
      token: ${{ secrets.TESSL_API_TOKEN }}
      # path: './path/to/tile' # Optional, defaults to current directory”
```

--------------------------------

### Querying Agent for Code Generation

Source: https://docs.tessl.io/use/make-your-agents-smarter-with-documentation

Example of prompting an AI agent, such as Claude Code, to utilize loaded tiles for specific framework tasks. The agent references the tessl.json file to access accurate documentation for the requested library.

```text
Build a hello world app using fastapi.
```

--------------------------------

### Query Library Docs API

Source: https://docs.tessl.io/reference/mcp-tools

Gathers relevant documentation context from installed tiles using AI-powered search. Authentication is handled automatically.

```APIDOC
## POST /query_library_docs

### Description
Gathers relevant documentation context from installed tiles using AI-powered search. Authentication is required and handled automatically.

### Method
POST

### Endpoint
/query_library_docs

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **query** (string) - Required - A question, task description, or topic about libraries/dependencies you need information about.

### Request Example
```json
{
  "query": "How do I create a reactive store in Svelte?"
}
```

### Response
#### Success Response (200)
- **context** (string) - Relevant documentation content chunks.

#### Response Example
```json
{
  "context": "In Svelte, you can create a reactive store using the `writable` function from 'svelte/store'. Example: `import { writable } from 'svelte/store'; export const count = writable(0);`"
}
```
```

--------------------------------

### Comprehensive tile.json with Docs, Rules, and Skills

Source: https://docs.tessl.io/reference/configuration

A comprehensive tile.json example demonstrating the integration of documentation, rules, and skills. This configuration showcases how to combine different content types to create a feature-rich tile for AI agents.

```json
{
    "name": "myorg/comprehensive-tile",
    "version": "2.0.0",
    "summary": "Complete tile with docs, rules, and skills",
    "docs": "docs/index.md",
    "steering": {
      "code-style": {
        "rules": "rules/code-style.md"
      }
    },
    "skills": {
      "database-helper": {
        "path": "skills/database-helper/SKILL.md"
      }
    }
  }
```

--------------------------------

### tile.json with Documentation and Rules

Source: https://docs.tessl.io/reference/configuration

An example of a tile.json configuration that includes both general documentation and specific rules. The 'docs' field points to the main documentation file, while the 'steering' object defines specific rule files for different aspects of the tile's functionality.

```json
{
    "name": "myorg/queue-connector",
    "version": "1.2.0",
    "summary": "Message queue SDK and its best practices for MyOrg",
    "docs": "docs/index.md",
    "steering": {
      "dead-letter-handling": {
        "rules": "rules/dead-letter-handling.md"
      },
      "dev-mode": {
        "rules": "rules/dev-mode.md"
      }
    }
  }
```

--------------------------------

### Tessl Tile Manifest (tile.json) Example

Source: https://docs.tessl.io/use/make-your-agents-smarter-with-documentation

The `tile.json` file is a manifest containing metadata about a Tessl tile. It includes the tile's name, version, documentation path, a PURL describing the package it represents, and a summary. The `describes` field is required when `docs` is present and points to a package.

```json
{
  "name": "tessl/pypi-fastapi",
  "version": "0.116.0",
  "docs": "docs/index.md",
  "describes": "pkg:pypi/fastapi@0.116.1",
  "summary": "FastAPI framework, high performance, easy to learn, fast to code, ready for production",
  "private": true
}
```

--------------------------------

### GET /eval/compare

Source: https://docs.tessl.io/reference/cli-commands

Compares agent scores across all runs for a local scenarios directory by fingerprinting local scenarios and fetching server results.

```APIDOC
## GET /eval/compare

### Description
Compares agent scores across all runs for a local scenarios directory. It fingerprints local scenarios and fetches matching results from the server.

### Method
GET

### Endpoint
tessl eval compare <path>

### Parameters
#### Path Parameters
- **path** (string) - Required - Path to the scenarios directory.

#### Query Parameters
- **--workspace** (string) - Optional - Workspace name or ID.
- **--breakdown** (boolean) - Optional - Show per-scenario detail with all runs.
- **--json** (boolean) - Optional - Output raw JSON.

### Request Example
```sh
tessl eval compare ./evals/ --breakdown
```

### Response
#### Success Response (200)
- **results** (array) - List of comparison results including scores and deltas.

#### Response Example
{
  "status": "success",
  "data": {
    "baseline_score": 0.85,
    "with_context_score": 0.92,
    "delta": 0.07
  }
}
```

--------------------------------

### Basic tile.json Configuration

Source: https://docs.tessl.io/reference/configuration

A fundamental example of a tile.json file, showcasing essential metadata such as name, version, documentation path, and a description of the package it relates to. This configuration is used to identify and describe tiles within the Tessl ecosystem.

```json
{
  "name": "tessl/npm-shadcn",
  "version": "3.6.0",
  "docs": "docs/index.md",
  "describes": "pkg:npm/shadcn@3.6.2",
  "summary": "CLI and programmatic API for adding UI components from registries. Supports multi-registry, dependency resolution, code transformation, and MCP integration for AI assistants.",
  "private": false
}
```

--------------------------------

### Create New Skill using Tessl CLI

Source: https://docs.tessl.io/create/creating-skills

Command to create a new skill. Can be run interactively for a guided experience or with flags to specify parameters like name, description, workspace, and path.

```shell
tessl skill new
```

```shell
# Create a new skill
tessl skill new --name "database-migration-helper" --description "When you need to create and manage database migrations" --workspace myworkspace --path ./my-skill
```

--------------------------------

### Publish Skill to Tessl Registry (Public)

Source: https://docs.tessl.io/create/creating-skills

Publishes a skill to the Tessl Registry as a public skill, making it available for anyone to install after approval. This requires the skill to have gone through the public request process.

```shell
tessl skill publish --workspace myworkspace --public
```

--------------------------------

### GET /tessl/scenario/list

Source: https://docs.tessl.io/reference/cli-commands

Lists recent scenario generation runs in reverse chronological order. Allows filtering by user, workspace, status, and limits the number of results.

```APIDOC
## GET /tessl/scenario/list

### Description
List recent scenario generation runs in reverse chronological order.

### Method
GET

### Endpoint
/tessl/scenario/list

### Parameters
#### Path Parameters
None

#### Query Parameters
* `--mine` (boolean, optional): Only show generation runs created by you
* `--workspace` (string, optional): Filter by workspace name
* `--limit` (number, optional): Maximum number of runs to display (default: 20)
* `--status` (string, optional): Filter by status. Supported values: `pending`, `in_progress`, `completed`, `failed`
* `--json` (boolean, optional): Output as JSON

#### Request Body
None

### Request Example
```sh
tessl scenario list --workspace=engteam --status=completed --limit=10
```

### Response
#### Success Response (200)
* `runs` (array): A list of scenario generation runs.
  * `id` (string): The unique ID of the generation run.
  * `status` (string): The status of the run (e.g., `completed`, `failed`).
  * `created_at` (string): Timestamp when the run was created.
  * `completed_at` (string): Timestamp when the run was completed.
  * `source` (string): The source from which scenarios were generated.

#### Response Example
```json
{
  "runs": [
    {
      "id": "019c4791-9eec-7458-b28a-6c94405a3d38",
      "status": "completed",
      "created_at": "2023-10-27T10:00:00Z",
      "completed_at": "2023-10-27T10:05:00Z",
      "source": "org/repo"
    }
  ]
}
```
```

--------------------------------

### Private Rules-Only tile.json Example

Source: https://docs.tessl.io/reference/configuration

Demonstrates a private tile.json configuration focused solely on providing rules. It includes a name, version, summary, and a 'steering' object that maps rule names to their respective markdown files, indicating subjective guidance for agents.

```json
{
    "name": "myorg/code-style",
    "version": "0.0.1",
    "summary": "TypeScript code style guidelines for MyOrg",
    "private": true,
    "steering": {
      "naming": {
        "rules": "rules/naming.md"
      },
      "exceptions": {
        "rules": "rules/exceptions.md"
      }
    }
  }
```

--------------------------------

### GET /tessl/scenario/view/{id}

Source: https://docs.tessl.io/reference/cli-commands

Inspects a specific scenario generation run by its ID. Displays run metadata and a table of generated scenarios, including titles and checklist item counts.

```APIDOC
## GET /tessl/scenario/view/{id}

### Description
Inspect a scenario generation run. Shows run metadata and a table of generated scenarios with titles and checklist item counts.

### Method
GET

### Endpoint
/tessl/scenario/view/{id}

### Parameters
#### Path Parameters
* `id` (string, optional): Generation run ID. Either `id` or `--last` query parameter is required.

#### Query Parameters
* `--last` (boolean, optional): View the most recent generation run. Either `id` path parameter or `--last` is required.
* `--json` (boolean, optional): Output as JSON

#### Request Body
None

### Request Example
```sh
tessl scenario view --last
```

### Response
#### Success Response (200)
* `run_metadata` (object): Metadata about the generation run.
  * `id` (string): The unique ID of the generation run.
  * `status` (string): The status of the run.
  * `created_at` (string): Timestamp when the run was created.
  * `completed_at` (string): Timestamp when the run was completed.
  * `source` (string): The source from which scenarios were generated.
* `scenarios` (array): A list of generated scenarios.
  * `title` (string): The title of the scenario.
  * `checklist_items` (number): The number of checklist items for the scenario.

#### Response Example
```json
{
  "run_metadata": {
    "id": "019c4791-9eec-7458-b28a-6c94405a3d38",
    "status": "completed",
    "created_at": "2023-10-27T10:00:00Z",
    "completed_at": "2023-10-27T10:05:00Z",
    "source": "org/repo"
  },
  "scenarios": [
    {
      "title": "Test scenario 1",
      "checklist_items": 5
    },
    {
      "title": "Test scenario 2",
      "checklist_items": 3
    }
  ]
}
```
```

--------------------------------

### Search Tessl Registry for Tiles

Source: https://docs.tessl.io/reference/mcp-tools

Searches the Tessl registry for tiles using a query string. The query can be a tile name, package URL (PURL), or HTTP URL. Authentication is required but handled automatically if needed. The output includes tile name, version, description, and installation command.

```json
{
  "query": "svelte"
}
```

--------------------------------

### Create and publish a documentation tile using the Tessl CLI

Source: https://docs.tessl.io/evaluate/evaluating-documentation

This workflow demonstrates how to initialize a new documentation tile project using the Tessl CLI, edit the documentation content, and publish the tile to the registry for evaluation.

```bash
# Create documentation
tessl tile new --name myworkspace/my-library-docs --docs

# Write your documentation
# Edit docs/index.md with structured guides

# Publish
tessl tile publish
```

--------------------------------

### Create and List Workspaces via CLI

Source: https://docs.tessl.io/reference/workspaces

Commands to initialize a new workspace and verify its existence in the system.

```bash
tessl workspace create engteam
tessl workspace list
```

--------------------------------

### Create Documentation Structure

Source: https://docs.tessl.io/create/creating-documentation

Commands to create the documentation directory and populate it with markdown content. This structure is referenced by the tile manifest to provide context to AI agents.

```bash
mkdir -p ./my-tile/docs
cat > ./my-tile/docs/index.md << 'EOF'
# Formatter Util

A colorful logging formatter for pretty terminal output.
EOF
```

--------------------------------

### Manage Tessl Tiles via CLI

Source: https://docs.tessl.io/create/creating-documentation

Commands to initialize, validate, and publish Tessl tiles. These commands ensure the tile structure is correct and accessible within the workspace.

```bash
tessl tile new --name myworkspace/util-formatter --path ./my-tile
tessl tile lint ./my-tile
tessl tile publish ./my-tile --workspace myworkspace
```

--------------------------------

### Uninstall Tessl CLI

Source: https://docs.tessl.io/introduction-to-tessl/installation

Commands to remove the Tessl CLI and associated configuration files from the system. Ensure all binaries and local data directories are cleared.

```bash
rm -rf ~/.local/bin/tessl ~/.local/share/tessl
rm -rf ~/.tessl
```

```bash
brew uninstall tessl
rm -rf ~/.local/bin/tessl ~/.local/share/tessl
rm -rf ~/.tessl
```

```bash
npm ls -g | grep tessl
npm uninstall -g @tessl/cli
npm uninstall -g tessl
rm -rf ~/.local/bin/tessl ~/.local/share/tessl
rm -rf ~/.tessl
```

--------------------------------

### Update Tessl CLI

Source: https://docs.tessl.io/introduction-to-tessl/installation

Commands to manually update the Tessl CLI to the latest version or a specific target version. Note that specific versioning is not supported via Homebrew.

```shell-session
tessl cli update
tessl cli update --target 0.63.4
```

```shell-session
npm update -g @tessl/cli
npm install -g @tessl/cli@0.63.4
```

--------------------------------

### Tessl CLI Commands for Tile Management

Source: https://docs.tessl.io/create/creating-documentation

This snippet demonstrates common Tessl CLI commands used for managing and publishing tiles. It includes editing documentation, updating version numbers, validating tile structure, and publishing new versions to a workspace.

```bash
# Edit your docs
vim my-tile/docs/index.md

# Update version in tile.json (e.g., from "1.0.0" to "1.1.0")
vim my-tile/tile.json

# Validate the changes
tessl tile lint ./my-tile

# Publish the updated version
tessl tile publish ./my-tile --workspace myworkspace
```

--------------------------------

### Update tile.json Workspace Name

Source: https://docs.tessl.io/evaluate/evaluate-skill-quality-using-scenarios

Modifies the `tile.json` file to specify the correct workspace name for running evaluations. This ensures that the evaluation is associated with a workspace where the user has publisher rights. The example shows a placeholder name being replaced with a valid one.

```json
{
  "name": "placeholder/repo-flow-mapper",
  ...
}
```

```json
{
  "name": "mycompany/repo-flow-mapper",
  ...
}
```

--------------------------------

### Writing Custom Scenarios

Source: https://docs.tessl.io/evaluate/evaluating-your-codebase

Instructions on how to manually create evaluation scenarios.

```APIDOC
## Writing Your Own Scenarios

### Description
Instructions on how to manually create evaluation scenarios without using `tessl scenario generate`.

### Method
Manual Scenario Creation

### Endpoint
N/A

### Parameters
#### Directory Structure
Create a directory for your scenario (e.g., `my-custom-scenario/`) within the `evals/` directory.

- **`evals/`**
  - **`my-custom-scenario/`**
    - **`task.md`**: The task description for the agent.
    - **`criteria.json`**: The scoring criteria.
    - **`scenario.json`**: The scenario definition.

#### `scenario.json` Configuration
- **`fixture.ref`**: Should be the parent of the ground truth commit.
- **`fixture.exclude`**: Defines what gets stripped for baseline and serves as the default `--context-pattern`.
```

--------------------------------

### CLI Configuration Management

Source: https://docs.tessl.io/reference/cli-commands

Commands for managing configuration settings within the Tessl CLI.

```APIDOC
## CLI Command: tessl config remove

### Description
Removes a specific value from a configuration array key.

### Method
CLI COMMAND

### Endpoint
tessl config remove <key> <value>

### Parameters
#### Arguments
- **key** (string) - Required - Configuration key for the array
- **value** (string) - Required - Value to remove from the array

### Request Example
`tessl config remove agents cursor`
```

--------------------------------

### Lint and Pack Tessl Tile Locally (Bash)

Source: https://docs.tessl.io/create/developing-tiles-locally

Commands to validate the structure and package a Tessl tile from the local filesystem. 'lint' checks for structural correctness, and 'pack' creates a distributable package.

```bash
tessl tile lint ./my-tile
```

```bash
tessl tile pack --output ./dist ./my-tile
```

--------------------------------

### POST /eval/run

Source: https://docs.tessl.io/reference/cli-commands

Executes evaluations for a specified tile or codebase scenarios directory. The CLI automatically detects the evaluation type based on the source content.

```APIDOC
## POST /eval/run

### Description
Runs evaluations for a tile or a codebase scenarios directory. The CLI auto-detects the eval type from the source (Codebase eval vs Tile eval).

### Method
POST

### Endpoint
tessl eval run

### Parameters
#### Query Parameters
- **source** (string) - Optional - Path to tile folder, tile.json, or scenarios directory. Defaults to current directory.
- **--workspace** (string) - Optional - Workspace name or ID.
- **--agent** (string) - Optional - Agent and model as agent:model. Repeatable.
- **--context-pattern** (string) - Optional - Glob patterns for context files (Codebase evals only).
- **--context-ref** (string) - Optional - Source commit for context files (infer, HEAD, or SHA).
- **--runs** (number) - Optional - Number of times to repeat each agent configuration.
- **--variant** (string) - Optional - Restrict variants (without-context, with-context).
- **--label** (string) - Optional - Description for the run.
- **--force** (boolean) - Optional - Re-run all evals, including solved cases.
- **--json** (boolean) - Optional - Output run IDs as JSON.

### Request Example
```sh
tessl eval run ./evals/ --agent=claude:claude-sonnet-4-6 --label "testing-run"
```

### Response
#### Success Response (200)
- **run_id** (string) - The unique identifier for the triggered evaluation run.

#### Response Example
{
  "run_id": "eval_abc123"
}
```

--------------------------------

### Import and Create tile.json for Tessl Skill

Source: https://docs.tessl.io/distribute/promote-or-claim-a-skill-you-have-created

Generates a tile.json configuration file for a skill by importing from a local directory. Requires the directory path containing SKILL.md and the target workspace name.

```shell
tessl skill import ./<directory with SKILL.md> --workspace <myworkspace>
```

--------------------------------

### Tessl MCP Configuration (JSON)

Source: https://docs.tessl.io/reference/custom-agent-setup/opencode

Defines the configuration for the Model-Centric Processing (MCP) in Tessl. This JSON file specifies how Tessl should be run locally, including the command to execute and whether it's enabled. It's essential for integrating Tessl's processing capabilities into your project.

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "tessl": {
      "type": "local",
      "command": ["tessl", "mcp", "start"],
      "enabled": true
    }
  }
}
```

--------------------------------

### POST /tessl/scenario/download

Source: https://docs.tessl.io/reference/cli-commands

Downloads generated scenarios to a local directory. Supports specifying output directory, write strategy (merge or replace), and downloading from the most recent run or specific run IDs.

```APIDOC
## POST /tessl/scenario/download

### Description
Download generated scenarios to your local `evals/` folder.

### Method
POST

### Endpoint
/tessl/scenario/download

### Parameters
#### Path Parameters
None

#### Query Parameters
* `--output` (string, optional): Output directory (default: `evals`)
* `--strategy` (string, optional): Write strategy: `merge` (default) adds new scenarios alongside existing ones; `replace` clears the directory first
* `--json` (boolean, optional): Output as JSON
* `--last` (boolean, optional): Download from the most recent generation run. Either `id` argument or `--last` is required.

#### Request Body
* `id` (string, required, repeatable): Generation IDs to download. Can specify multiple IDs. Either `id` argument or `--last` query parameter is required.

### Request Example
```sh
tessl scenario download --last --output=my-evals --strategy=replace
```

### Response
#### Success Response (200)
* `message` (string): Confirmation message indicating the scenarios were downloaded.
* `downloaded_paths` (array): List of paths where scenarios were downloaded.

#### Response Example
```json
{
  "message": "Scenarios downloaded successfully.",
  "downloaded_paths": [
    "evals/abcde12-scenario-title",
    "evals/fghij34-another-scenario"
  ]
}
```

### Downloaded Structure
```
evals/
  <7-char-hash>-<slug>/
    task.md          ← task brief shown to the agent
    criteria.json    ← weighted checklist rubric
    scenario.json    ← fixture with repo URL, commit ref, and context exclude patterns
```
```

--------------------------------

### Publish Tile via Tessl CLI (Shell)

Source: https://docs.tessl.io/distribute/sharing-tiles-publicly

This shell command is used to publish or republish a Tessl tile after its configuration has been updated. Executing `tessl tile publish` makes the tile, configured as public, available in the Tessl Registry for internet-wide access. Ensure you have the Tessl CLI installed and are authenticated.

```shell
tessl tile publish
```

--------------------------------

### Run and Compare Evaluations using Tessl CLI

Source: https://docs.tessl.io/evaluate/evaluating-your-codebase

These commands execute and compare evaluation scenarios. The `run` command executes evaluations from a specified directory, and the `compare` command compares the results, with options for detailed breakdowns. Both require a workspace.

```bash
$ tessl eval run ./evals/ --workspace=<workspace>
$ tessl eval compare ./evals/ --breakdown --workspace=<workspace>
```

--------------------------------

### Configure Tile for Public Sharing (JSON)

Source: https://docs.tessl.io/distribute/sharing-tiles-publicly

This JSON configuration snippet demonstrates how to set the 'private' field to 'false' in a tile.json file, making the tile publicly discoverable. This setting allows anyone to find and install the tile via the Tessl Registry. Once set to false, a tile cannot be made private again.

```json
{
  "name": "myworkspace/my-tile",
  "version": "1.0.0",
  "summary": "My public tile",
  "private": false,
  "docs": "docs/index.md"
}
```

--------------------------------

### List and view scenario generation runs

Source: https://docs.tessl.io/reference/cli-commands

Commands to list recent generation runs and inspect specific run metadata. Useful for tracking progress and identifying IDs for further actions.

```shell
tessl scenario list
tessl scenario view --last
tessl scenario view 019c4791-9eec-7458-b28a-6c94405a3d38
```

--------------------------------

### Configure tile.json for Skill Referencing

Source: https://docs.tessl.io/create/creating-skills

This JSON configuration defines a tile structure, mapping a skill name to its corresponding SKILL.md file path. It is essential for the tile-first development workflow to ensure the registry correctly identifies and packages your skills.

```json
{
  "name": "myworkspace/my-skill",
  "version": "1.0.0",
  "skills": {
    "my-skill": {
      "path": "skills/my-skill/SKILL.md"
    }
  }
}
```

--------------------------------

### Define Tile Manifest in tile.json

Source: https://docs.tessl.io/create/creating-documentation

The tile.json file serves as the configuration manifest for a Tessl tile. It defines metadata, versioning, and the entry point for documentation.

```json
{
  "name": "myworkspace/util-formatter",
  "version": "1.0.0",
  "summary": "A colorful logging formatter for pretty terminal output",
  "docs": "docs/index.md",
  "describes": "pkg:npm/my-company/util-formatter@1.0.0",
  "private": true
}
```

--------------------------------

### Review Skill for Comprehensive Recommendations

Source: https://docs.tessl.io/create/creating-skills

Performs a more comprehensive review of the skill, providing detailed recommendations for improvement. This command helps identify potential issues beyond basic linting.

```shell
tessl skill review ./my-skill
```

--------------------------------

### Run Tessl Evaluations

Source: https://docs.tessl.io/reference/cli-commands

Executes evaluations for a given tile or codebase scenarios directory. The CLI automatically detects the evaluation type based on the source content. Supports various flags to customize agent selection, context injection, and run behavior.

```shell
tessl eval run [--workspace <name>] [--agent <agent:model>]... [--context-pattern "<globs>"] [--context-ref <infer|HEAD|SHA>] [--runs <count>] [--variant <name>]... [--label <text>] [--force] [--json] [<source>]
```

--------------------------------

### Model Context Protocol

Source: https://docs.tessl.io/reference/cli-commands

Commands for managing the MCP server.

```APIDOC
## CLI Command: tessl mcp start

### Description
Starts the Tessl MCP server for integration with AI coding agents.

### Method
CLI COMMAND

### Endpoint
tessl mcp start
```

--------------------------------

### Create New Tessl Tile or Skill (Bash)

Source: https://docs.tessl.io/create/developing-tiles-locally

Commands to create a new Tessl tile or a new skill within a tile. These commands set up the basic directory structure for your tile content.

```bash
tessl skill new --name my-skill --path ./my-tile/skills/my-skill
```

```bash
tessl tile new --name myworkspace/my-tile --path ./my-tile
```

--------------------------------

### Download generated scenarios

Source: https://docs.tessl.io/reference/cli-commands

Downloads generated scenario files to a local directory. Supports custom output paths and strategies for merging or replacing existing files.

```shell
tessl scenario download --last
tessl scenario download --last --output=my-evals --strategy=replace
tessl scenario download 019c4791-9eec-7458-b28a-6c94405a3d38
```

--------------------------------

### Run Tessl Evaluation with Default Settings

Source: https://docs.tessl.io/evaluate/evaluate-skill-quality-using-scenarios

Executes the Tessl evaluation process by providing the path to the `tile.json` file. This command assumes the `evals/` directory is located within the same directory as the `tile.json` file. It uses the default Claude Sonnet model.

```bash
tessl eval run <path/to/tile>
```

--------------------------------

### Generate evaluation scenarios with Tessl CLI

Source: https://docs.tessl.io/reference/cli-commands

Generates eval scenarios from a tile or repository commits. This command runs server-side and supports filtering by commits, PRs, or workspaces.

```shell
tessl scenario generate org/repo --commits=abc123,def456
tessl scenario generate org/repo --prs=42,43
tessl scenario generate ./my-tile --count=5
tessl scenario generate org/repo --commits=abc123 --context="*.mdc,*.md"
tessl scenario generate org/repo --commits=abc123 --workspace=engteam
```

--------------------------------

### Manage Authentication and Workspace Access

Source: https://docs.tessl.io/support/troubleshooting

Commands for managing user sessions and verifying workspace membership permissions.

```bash
tessl logout
tessl login
tessl whoami
tessl workspace list-members <workspace-name>
```

--------------------------------

### Diagnostics and Utilities

Source: https://docs.tessl.io/reference/cli-commands

Diagnostic tools for troubleshooting authentication and sending feedback.

```APIDOC
## CLI Command: tessl doctor

### Description
Runs authentication and manifest diagnostics to troubleshoot issues.

### Method
CLI COMMAND

### Endpoint
tessl doctor [--json]

### Parameters
#### Flags
- **--json** (boolean) - Optional - Output diagnostics as JSON

## CLI Command: tessl feedback

### Description
Sends feedback to the Tessl team.

### Method
CLI COMMAND

### Endpoint
tessl feedback [<message>]

### Parameters
#### Arguments
- **message** (string) - Optional - Feedback content
```

--------------------------------

### Initialize Tessl MCP Server Configuration

Source: https://docs.tessl.io/reference/mcp-tools

Initializes the Tessl MCP server configuration for an AI coding agent. This command-line tool sets up the necessary configuration to allow agents to connect to and utilize the Tessl registry.

```sh
tessl init --agent <agent-name>
```

--------------------------------

### Compare Tessl Evaluation Results

Source: https://docs.tessl.io/reference/cli-commands

Compares agent scores across multiple evaluation runs for a local scenarios directory. It fingerprints local scenarios and fetches corresponding results from the server. Options include displaying a detailed breakdown per scenario.

```shell
tessl eval compare <path> [--workspace <name>] [--breakdown] [--json]
```

--------------------------------

### List All Tessl Evaluation Runs

Source: https://docs.tessl.io/evaluate/evaluate-skill-quality-using-scenarios

Provides a comprehensive list of all recorded Tessl evaluation runs, including their IDs and current statuses. This command helps in managing and tracking multiple evaluation efforts.

```bash
tessl eval list
```

--------------------------------

### Generate Scenarios from Commits using Tessl CLI

Source: https://docs.tessl.io/evaluate/evaluating-your-codebase

This command sequence generates scenarios from specified Git commits within a repository. It first selects commits based on a keyword and then generates scenarios using those commits. Finally, it downloads the generated scenarios.

```bash
$ tessl repo select-commits org/repo --keyword=feat --workspace=<workspace>
$ tessl scenario generate org/repo --commits=abc123,def456 --workspace=<workspace>
$ tessl scenario download --last
```
Tokens:
Raw