Use Sigma's open-source agent skills to give AI coding assistants direct knowledge of Sigma's REST API and data modeling workflows — then put them to work building against Sigma without writing boilerplate from scratch.

Sigma publishes agent skills through the sigma-agent-skills GitHub repository. These skills are reference files that tell a coding agent how to authenticate with Sigma, call the API, and create or update data models — the same patterns you'd write by hand, now available to any supported AI assistant automatically.

In this QuickStart, you'll learn how to:

For more information on Sigma's product release strategy, see Sigma product releases

If something doesn't work as expected, here's how to contact Sigma support

Target Audience

This QuickStart is for developers and technical users who work with AI coding assistants and want to use them to build against Sigma's REST API or manage data models programmatically.

Prerequisites

Sigma Free Trial

Footer

Agent skills are structured reference files that tell an AI coding assistant how to work with a specific platform or API.

Instead of relying on the agent's general training data — which may be outdated or incomplete — skills give the agent precise, current instructions it can follow during a session.

Sigma's agent skills are open source and distributed through the sigma-agent-skills GitHub repository. When installed, they extend your AI assistant with Sigma-specific knowledge so you can interact with Sigma's APIs using natural language prompts rather than writing raw API calls by hand.

At the time of this QuickStart, there are two skills available, with many more planned.

sigma-api:
 Provides the agent with instructions for authenticating to Sigma's REST API using client credentials. This includes how to obtain a bearer token, how to pass it in API requests, and troubleshooting guidance for common authentication errors. With this skill active, you can ask the agent to list workbooks, retrieve document metadata, manage members, or perform any other operation exposed by Sigma's REST API

sigma-data-models:
 Provides the agent with instructions for creating and managing Sigma data models programmatically. This includes the authentication flow, how to gather metadata about available connections and tables, and how to construct and submit data model specifications. With this skill active, you can ask the agent to build a new data model, update an existing one, or inspect what's already deployed.

How Skills Work

When a skill is loaded into an AI assistant, the assistant reads the skill's reference files at the start of a session. From that point forward, it uses those instructions to guide its API calls, authentication steps, and troubleshooting decisions — without you needing to supply that context manually.

The skills wrap Sigma's APIs but do not replace them. You still need a valid Sigma account and API credentials. The agent handles the mechanics; your credentials and permissions determine what it can do.

Footer

In preparation for using the API, we need to use Sigma to generate a new API token.

Log onto Sigma (as Administrator). Navigate to Administration > Developer access.

Click the Create New button:

Select REST API, give it a name and description. Some customers create a Service Account user for automation purposes; this is a best practice. Since we are just testing, you can choose any Admin user you prefer. Click Create.

Copy the ClientID and Secret from the popup and save them to a secure location. We will use them later. Close the popup:

Also copy the API base URL:

Footer

This section walks through setup using VSCode with Claude Code. For installation on other platforms, see Install skills for AI assistants.

Create a Working Directory

Create a dedicated folder for this project. Open a terminal and run:

mkdir sigma-skills-demo
cd sigma-skills-demo

Open in VSCode

From the same terminal, open the folder in VSCode:

code .

Open an Integrated Terminal

In VSCode, open the integrated terminal with Terminal > New Terminal. This keeps your work in a single window.

Store Your API Credentials Securely

The Sigma skills authenticate using your API client ID and client secret. Rather than entering credentials directly into prompts — where they can appear in session logs or chat history — store them in a .env file in your project folder and load them as shell environment variables. Claude Code inherits environment variables from the shell it was launched from, so loading credentials before starting Claude is the cleanest approach.

Step 1:
 In VSCode, create a new file named .env in the sigma-skills-demo folder with the following content, replacing the placeholder values with your actual credentials:

export SIGMA_CLIENT_ID=your_client_id_here
export SIGMA_CLIENT_SECRET=your_client_secret_here
export SIGMA_BASE_URL=https://aws-api.sigmacomputing.com

If you're unsure where Sigma is hosted, you can find it in Sigma > Administration > General Settings > Site:

For the list of API endpoints by cloud platform and region, see Supported regions, data platforms, and features

Step 2: In the VSCode terminal, load the environment variables into your shell session:

source .env

There is no reply in the terminal unless there is an error.

These variables are now available in the current shell session.

Starting Claude Code after this step ensures it inherits SIGMA_CLIENT_ID, SIGMA_CLIENT_SECRET, and SIGMA_BASE_URL automatically — no credentials in any prompt.

Start Claude Code

From the VSCode terminal, start Claude Code:

claude

Claude Code launches in the terminal, ready to accept commands.

Install the Sigma Skills

With Claude Code running, install the Sigma plugin using these two commands in sequence.

The first command registers the sigma-agent-skills repository as a marketplace source:

/plugin marketplace add https://github.com/sigmacomputing/sigma-agent-skills.git

The response will be:

Successfully added marketplace: sigma-computing

The second installs the Sigma plugin from that source:

/plugin install sigma-computing@sigma-computing

Claude Code displays an interactive panel showing the plugin details and a trust warning before proceeding. Review the details, then use the arrow keys to select an installation scope and press Enter to confirm.

The three scope options are:

The response will be:

Installed sigma-computing. Run /reload-plugins to apply.

Run the reload command to activate the plugin in the current session:

/reload-plugins

The response will confirm the plugin loaded:

Reloaded: 1 plugin · 0 skills · 5 agents · 0 hooks · 0 plugin MCP servers · 0 plugin LSP servers

For reference, see Claude Code plugin discovery

Other AI Assistants

For assistants not directly listed in Sigma's documentation, manually reference the skill files located in the skills/ directory of the cloned repository. Add them to your assistant's context using whatever mechanism the tool provides for injecting reference documents — custom instructions, system prompts, context files, or similar.

Footer

With the skill installed and credentials loaded into the environment, we are ready to provide the assistant with prompts that use Sigma's REST API. This section walks through the basic flow using Claude Code as the primary example. The same prompt patterns apply in other supported assistants.

Credentials

If you completed the setup in the previous section, your credentials are already loaded as environment variables (SIGMA_CLIENT_ID, SIGMA_CLIENT_SECRET, and SIGMA_BASE_URL). Claude Code inherits these from the shell, so the agent can authenticate without you supplying credentials in any prompt.

Authenticate and Make an API Call

Let's use the skill's authentication instructions to obtain a bearer token using your environment variables, then pass it in subsequent API requests.

A simple starting prompt:

Using the sigma-api skill with my API credentials from the environment, list all the workbooks I have access to.

The agent will:

  1. Read SIGMA_CLIENT_ID and SIGMA_CLIENT_SECRET from the shell environment
  2. Follow the skill's instructions to obtain a bearer token from the Sigma token endpoint
  3. Call the appropriate Sigma REST API endpoint
  4. Return the results in a readable format

Example Prompts

With the sigma-api skill active, you can prompt the agent to perform any operation the Sigma REST API supports. Some practical examples:

List all members in my Sigma organization.

Show all workbooks I have access to.

Get the details for one of the listed workbooks.

List all connections available in my Sigma environment.

Create a new folder called "Analytics Reports" in "Your documents".

The agent translates these prompts into authenticated API calls using the skill's reference instructions. It also applies the skill's troubleshooting guidance if authentication fails or an API call returns an error.

Use Sigma to verify the request:

Working with API Results

The agent returns results as structured text or code, depending on how you frame the prompt. To get output you can use downstream, be specific about the format:

List all workbooks and return the results as a JSON array with workbook ID and name only.

Get all members and save the results to a file named `sigma_members.csv`.

For a full reference of available Sigma REST API endpoints, see the Sigma API documentation

Footer

The sigma-data-models skill gives your AI assistant the instructions it needs to create and manage Sigma data models programmatically. This section walks through how to prompt the agent to build a new data model and update an existing one, using Sigma sample data.

How the Skill Approaches Data Model Creation

Before creating a data model, the agent needs to gather metadata about your Sigma environment — specifically, which connections are available and which tables exist in a given connection. The sigma-data-models skill includes instructions for this metadata-gathering step, so the agent handles it automatically when you reference a connection or table in your prompt.

The general flow is:

  1. Agent authenticates using your API credentials
  2. Agent queries available connections in your Sigma environment
  3. Agent retrieves table metadata from the relevant connection
  4. Agent constructs a data model specification and submits it via the API

Create a New Data Model

Describe what you want to model and where the data lives:

Create a new Sigma data model using the RETAIL.PLUGS_ELECTRONICS schema in our Snowflake connection. Include the F_POINT_OF_SALE table.

The agent authenticates, gathers the necessary metadata from your connection, builds the data model specification, and submits it to Sigma's API.

We can verify the data model was created in the requested location in Sigma:

Update an Existing Data Model

With the model in place, you can iterate on it through follow-up prompts — adding related tables, joins, and calculated columns without leaving the conversation.

Add a related table and join:

Add the D_PRODUCT table from the same schema to the data model we just created. Join it to F_POINT_OF_SALE on PRODUCT_KEY.

In Sigma, we see the second table has been added to the data model:

Add a calculated column:

Update the same data model to include a calculated column: GROSS_PROFIT as SALES_AMOUNT minus COST_AMOUNT.

The agent retrieves the current data model definition, applies the requested changes, and submits the updated specification back to the API:

We can see our new calculated column in current-spec.json:

And also see it in Sigma:

Inspect Deployed Data Models

Let's use the skill to pull the full definition of the data model we just built:

Show me the current definition of the data model we just created from the RETAIL.PLUGS_ELECTRONICS schema.

The agent returns the tables, joins, and calculated columns currently in the model — useful for confirming a change landed as expected, or for diffing the live spec against the local current-spec.json file.

For more on Sigma data models and their structure, see Data models

Footer

The published Sigma skills work out of the box for standard API and data model workflows, but many organizations have conventions and context that make a customized version more effective.

Because the skills are open source and built from plain text reference files, extending them is straightforward. In this section we'll make a quick local customization to see it in action, then point you to the durable workflow for changes you want to keep.

What's in a Skill File

Each skill is a structured text document that gives the agent instructions for a specific domain. The files describe:

These are reference documents — not code — so editing them requires no programming. You are adding or modifying natural language instructions that the agent reads and follows.

Browse the Source (Optional)

If you'd like a local copy of the skill files to browse alongside this section, clone the repo. First, exit Claude Code so the terminal is back at the shell prompt:

/exit

Confirm you're in sigma-skills-demo, then clone the repo as a subdirectory:

git clone https://github.com/sigmacomputing/sigma-agent-skills.git

This creates sigma-skills-demo/sigma-agent-skills/. The skill files live under skills/:

Make a Quick Local Customization

We'll add a small change the marketplace version doesn't make — an extra column when listing workbooks and a footer line on every list response. Both are easy to spot in the result, so you'll know immediately when the customization is active.

For quick local iteration, edit the plugin files Claude Code reads at runtime. These live in the local plugin cache. For example, on a Mac:

/Users/YOU/.claude/plugins/cache/sigma-computing/sigma-computing/0.1.3/skills/

The 0.1.3 directory matches the installed plugin version. If your installed version differs, adjust the path accordingly.

In VSCode, open sigma-api/SKILL.md from that path. From a terminal you can also run (substitute your home folder name for YOU):

code /Users/YOU/.claude/plugins/cache/sigma-computing/sigma-computing/0.1.3/skills/sigma-api/SKILL.md

Scroll to the bottom of the file and append:

## Custom Output Format

When listing workbooks, present the results as a markdown table with these exact columns in order: Name, Workbook ID, Path, Last Updated. The Workbook ID column must appear before Path and must show the full UUID.

When listing members or connections, present as a markdown table with one row per item and concise column headers.

At the end of every list response, append a footer line on its own:
_Source: local sigma-api skill customization._

Save the file. In Claude Code, reload plugins to pick up the change. Start Claude Code first with

claude

if you exited it earlier:

/reload-plugins

Validate

Run a prompt that exercises the customization:

Using the sigma-api skill, list the workbooks in my Sigma organization.

You should see two unmistakable signals that your customization is active:

If both appear, your customization is being read and your edits are working:

If the table still has only Name / Path / Last Updated and no footer, confirm you saved SKILL.md after editing, then re-run /reload-plugins in Claude Code.

Making Customizations Permanent

The cache edit above is fine for testing, but it won't survive a reinstall or upgrade. To keep a customization durable, treat the skill repo like any other open-source project — fork it on GitHub, push your edits, and install from your fork instead of the upstream marketplace.

This workflow assumes you have a GitHub account and basic familiarity with Git (clone, commit, push). If forking is new to you, see GitHub's guide to forking a repository before continuing.

Step 1: Fork and clone

Fork sigma-agent-skills on GitHub, then clone your fork into a new folder so it doesn't collide with the earlier sigma-skills-demo work. Replace your-github-user with your GitHub username:

git clone https://github.com/your-github-user/sigma-agent-skills.git
cd sigma-agent-skills

Step 2: Remove the upstream install

If you followed earlier sections, Claude Code already has the upstream marketplace and plugin installed. Remove both before pointing at your fork — otherwise Claude Code can reuse the cached upstream plugin even after you add the new marketplace.

In your running Claude Code session, uninstall the plugin and remove the marketplace:

/plugin uninstall sigma-computing@sigma-computing

/plugin marketplace remove sigma-computing

Exit Claude Code:

/exit

Clear the plugin cache (replace YOU with your home folder name):

rm -rf /Users/YOU/.claude/plugins/cache/sigma-computing

Step 3: Point the marketplace at your fork

In your clone, open .claude-plugin/marketplace.json and set the plugin's source field to ".". The dot tells Claude Code that the plugin lives inside the marketplace repo itself — i.e., your fork:

"plugins": [
  {
    "name": "sigma-computing",
    "source": { "source": "." },
    ...
  }
]

Step 4: Edit SKILL.md

Open skills/sigma-api/SKILL.md and append a customization.

## Custom Output Format

At the end of every list response, append a footer line on its own:
_Source: local sigma-api skill customization based on fork._

If you also use Snowflake Cortex Code with this fork, mirror the same change in .cortex/skills/sigma-api/SKILL.md.

Step 5: Commit and push — before installing

Push your changes to your fork's default branch.

This must happen before the marketplace add in step 7, since the installer reads from the remote, not your working copy:

git add .claude-plugin/marketplace.json skills/sigma-api/SKILL.md
git commit -m "Add custom output footer for sigma-api"
git push origin main

(Substitute master for main if that's your fork's default branch.)

Step 6: Create an environment file

Each clone needs its own .env. Create one in the root of the new folder with the same contents as in Store Your API Credentials Securely, then source it:

source .env

Step 7: Install from your fork

Start Claude Code:

claude

Register your fork as the marketplace and install the plugin:

/plugin marketplace add https://github.com/your-github-user/sigma-agent-skills.git

/plugin install sigma-computing@sigma-computing

Step 8: Verify the install came from your fork

Exit Claude Code and confirm the cached plugin's git remote points at your fork:

/exit

git -C /Users/YOU/.claude/plugins/cache/sigma-computing/sigma-computing/0.1.3 remote -v

The origin URL must end in your-github-user/sigma-agent-skills.git. If you see sigmacomputing/sigma-agent-skills.git, the marketplace resolved to upstream — recheck that step 3's source field was set to "." and that step 5 pushed those changes to the default branch before you ran step 7.

Step 9: Validate in a fresh session

Skill descriptions are loaded once at session start, so always validate in a session started after the install — not the one you ran the install commands in.

claude

/reload-plugins

Using the sigma-api skill with my API credentials from the environment, list all the workbooks I have access to.

The response should end with the footer line _Source: local sigma-api skill customization based on fork._. If it doesn't, return to step 8 and confirm the remote.

The result is a versioned, durable copy of the skill your team can iterate on with standard Git workflows — branches, pull requests, and code review.

What Else to Customize

Once you have a working local fork, common org-specific additions include:

Contributing Back

If your customization addresses a general gap — a missing endpoint, improved error handling, a clearer instruction — consider submitting a pull request to the sigma-agent-skills repository. The Apache 2.0 license makes contribution straightforward, and improvements benefit the broader community of Sigma users building with AI assistants.

Footer

Sigma agent skills bring your AI coding assistant into Sigma's API ecosystem. Rather than context-switching between documentation, terminal, and code editor, you describe what you want in plain language and the agent handles authentication, API mechanics, and error handling using Sigma's own reference materials.

The two skills available today — sigma-api and sigma-data-models — cover the most common developer entry points: interacting with Sigma programmatically and managing analytics infrastructure as code. As Sigma adds more skills to the repository, the same installation pattern applies.

Because the skills are open source, they can be extended, versioned, and improved through community contributions — making this a foundation that grows with use.

Additional Resource Links

Blog
Community
Help Center
QuickStarts

Be sure to check out all the latest developments at Sigma's First Friday Feature page!

   

Footer