Changelog

Skills are reusable instruction packs Supersimple's AI agent can load for specific kinds of work. When relevant to the current question, the AI pulls in the skill's full instructions on-demand.

This keeps your base system instructions focused and clear while still giving the agent deep, task-specific guidance where needed. Use skills to capture how your team writes a weekly report, finds the latest contract for a vendor, or any other recurring or complex workflow.

Skills can also be permissioned based on user attributes. Keep in mind that data access permissions still always apply, so the agent will only be able to pull in information from sources and data models the user has access to.

Manage skills under account settings → AI → Agent skills.

AI now collapses steps like intermediary outputs, debug queries, and more. This means you still see everything it did, while keeping the clean, final output front and center.

Accepting the AI's response drops these intermediary steps by default.

Custom formulas now include a dedicated set of array functions for working with list values:

Read more in the custom formulas reference.

Date Range variables let you use a single Variable for both the start and end date of a filter. Pick a Dynamic range like "this month", or use Specific dates for things like "January 4th" or "all of February 2026".

You can also type the date range you're looking for in plain English, and see a real-time preview of how we interpreted your input.

Applying the Date Range variables to queries is as easy as filtering for some field "is" and then picking your Date Range variable from the dropdown.

Variables now list every block that uses them, right in the settings sidebar, under "Used in".

User groups

User groups allow setting parameters for multiple users at once. Define groups with specific parameters and assign users to them. This way, you can manage permissions for teams or departments without configuring each user individually. User groups can be configured by account admins under settings.

Model-level permissions

Model-level permissions control who can see and query a data model. Hide entire models from users based on their parameters like properties given via user groups or their email.

Define an access block on the model and combine conditions with AND/OR logic to match departments, regions, specific emails, or anything else on the user.

models:
  salaries:
    name: Salaries
 
    table: hr.salaries
 
    access:
      user_parameters:
        department: hr
        data_level: sensitive
 
    properties:
      employee_id:
        name: Employee ID
        type: String
      salary:
        name: Salary
        type: Number

Row-level permissions

You can now also use custom user parameters in addition to the user's email to filter rows within a model.

Row-level permissions filter which rows a user can access within a model, using {{user_parameters.<key>}} placeholders injected into SQL at query time. Reference the placeholder in the model's sql and each user sees only the rows matching their own parameters.

models:
  orders:
    name: Orders
 
    sql: |-
      SELECT * FROM orders
      WHERE region IN ({{user_parameters.region}})
 
    properties:
      order_id:
        name: Order ID
        type: String
      region:
        name: Region
        type: String

Read more in the documentation.

Metrics are now also listed on the Data Models canvas under account settings, below the properties of the relevant data model.

Python blocks now run in configurable sandboxes, instead of using Pyodide in your browser. This means support for any Python package and removes the memory limits of your browser tab.

Sandboxes are isolated between customers, and the default Docker image and machine resources (CPU, memory, and disk) are all configurable.

To use Python blocks inside dashboards, alongside other native blocks, you can now set them to auto-run on exploration load, and hide the code so only the output is shown – both from the right-hand sidebar.

You can now define individual columns on a table-based model using a SQL expression, right where you define other column metadata.

properties:
  name:
    name: Name
    type: String
    sql: "case when {is_internal} then concat('(INTERNAL) ', {name}) else name end"
  name_upper:
    name: Name (uppercase)
    type: String
    sql: "upper({name})"
    description: "The name column, but in uppercase"

Use {column_name} to reference another column, whether from the source table or computed under properties using sql.

You can also use these sql-defined properties in any operations on the same data model, including filters.

Read more in the docs.

Improved multi-sorting of tables. Go to "Edit Sort" in the block options menu to set the columns and their exact order in the sort.

Apply conditional formatting to tables to visually highlight individual values or entire rows based on rules you define.

You can now export your models, metrics, and saved explorations to YAML files using Supersimple's CLI. Run supersimple export to try it out!

The import and validate commands have also been upgraded to support glob patterns and directories.

# Export models, metrics, and explorations:
supersimple export -o my-config/
 
# Export just the explorations:
supersimple export --explorations -o my-config/
 
# Import all explorations from a directory:
supersimple import explorations/
 
# Import using glob patterns:
supersimple import models/user-*.yaml
 
# See available flags:
supersimple export --help
supersimple import --help

This is particularly useful for managing large bulk changes, including refactoring your data model. You can export your current configuration, make changes in the YAML files, and then re-import everything to apply the updates. On your own, or by letting your coding agent use the CLI.

Read more in the CLI docs.

Variables can now be duplicated within the same exploration or copied across explorations.

Semantic layers are great, but it's impossible for them to cover everything. One of the most useful sources for additional context is your codebase itself!

That's why we're pumped to announce Supersimple's native GitHub agent for finding definitions and gotchas from code – things that the analytics agent needs to know about.

Supersimple's GitHub integration spawns powerful coding agents to roam around your repos and pull requests. Pick the repos you'd like to include when setting up the integration, and we'll take care of everything else.

Bringing the context of your codebase into BI is a huge unlock. We can't wait to hear what you think, and all the use cases this unlocks!

Supersimple's been in dark-mode-only from (almost) day one, and we know many of you love it that way.

We know some do prefer light mode for various reasons, though – and we want to give everyone a delightful experience. So – here you go!

Find the new "App appearance" toggle under your account settings.

Custom formulas now support percentile(field, percentile) for nearest-rank percentile calculations.

Example: percentile(prop("Duration (ms)"), 90) returns the p90 duration (meaning 90% of data points are at or below the p90 value).

Read more in the custom formulas reference.

For whenever you really need some custom SQL: schema-aware SQL autocomplete now makes that a smoother experience.

Suggestions include field names, schemas/datasets, and database functions and keywords.

AI can now reference and cite information from earlier messages in the conversation without re-searching. This makes responses faster and more context-aware.

Supersimple's AI can now choose to query data in addition to simply operating with model and exploration metadata.

This makes the agent significantly more capable of debugging data issues, cross-referencing things, and jumping back-and-forth between structured and unstructured data sources.

You have full control over which data models the AI may access. Currently available under Research mode for select accounts.

You can now pin your favorite explorations to the sidebar for quick access. Pinning is personal and doesn't affect other team members.

Model relations now support plain SQL syntax, providing more flexibility when defining relationships between data models. Learn more in our docs.

You can now move blocks between tabs by dragging and dropping them into the sidebar. Or the other way around.

The page now automatically scrolls when you drag a block's resize handle near the edge, making it easier to resize blocks that extend beyond the viewport.

Any block can now be exported as a PNG image, either by copying to clipboard or downloading directly.

Summarize filters now let you directly access fields behind hasOne relations, matching how how Filter and New Column steps already worked.

You can now rename exploration tabs by double-clicking on the tab button at the top of the page.

This is the biggest upgrade to Supersimple's AI agent since its inception in 2023 – a result of months of effort.

The agent is now significantly stronger at picking and choosing among enabled data sources, and iterating based on intermediary findings.

You can now drag and drop blocks between tabs using the table of contents for easier exploration organization.

Instead of messing with Slack webhooks, you can now directly select between Slack channels to send Alerts to.

Note: this requires you to install the Supersimple Slack bot under account settings.

Hovering over chart legend items now highlights the corresponding data in the chart, making it easier to understand what's what.