Changelog

SAML SSO available as an add-on

SAML Single Sign-On is no longer reserved for the Enterprise plan: Pro teams can now enable it as an add-on for $200/month.

Your team settings also gain a new Add-ons section under Billing, giving you a clear overview of the add-ons activated on your account — GitHub SSO and SAML SSO — with their price, status, and the ability to enable or disable them in one click. Add-ons are billed monthly with your existing Stripe subscription.

Learn more in the SAML SSO documentation.

MCP server

Argos now speaks the Model Context Protocol. The official Argos MCP server is live at https://mcp.argos-ci.com — add it to your AI assistant and it can work with your Argos projects directly:

• Inspect builds — list builds and dig into their screenshot diffs.
• Review changes — approve or reject builds and dismiss reviews.
• Collaborate — read and post comments on builds.
• Query your account — retrieve project metadata and account analytics.

Tools are generated straight from the Argos REST API: every operation you can call is exposed as an MCP tool with the same name, parameters, and permissions — so when the API gains an endpoint, your agent gains the matching tool.

claude mcp add --transport http argos https://mcp.argos-ci.com

Sign in with OAuth, stay in control

The server implements the latest MCP authorization spec: add the URL to Claude Code, Claude.ai, Cursor, VS Code, Codex, or Windsurf, and your client opens a browser to sign in. You choose which organizations to share and which scopes to grant, and you can revoke access anytime from Authorized applications in your Argos settings. Personal access tokens are supported too, for clients where OAuth is impractical.

The MCP server joins the CLI, agent skills, and AI-ready docs in a new Agents section of the documentation.

👉 Set up the MCP server in the docs

Analytics revamp

Analytics used to tell you how much you tested. Now it tells you how visual testing is going. The account analytics page has been redesigned around a scan-then-explore hierarchy: a KPI band answers the big questions at a glance, and themed sections let you dig into where activity, changes, and reviews concentrate — across every project in your account.

• Four KPIs at a glance — Builds and Screenshots with trend sparklines, joined by two new rates: Change rate, the share of builds where Argos detected changes, and Approval rate, the share of reviewed builds your team approved.
• Build outcomes — follow changes detected vs. no changes and approvals vs. rejections over time, rendered in the same status colors you know from builds.
• Activity and breakdown by project — builds created and screenshots captured per project, a screenshots-by-project donut, and screenshots per build.
• Richer CSV exports — every chart exports its underlying data, and builds now include changes detected, no changes, approved, and rejected columns.

Scope the whole page to the projects you care about, pick a preset period — 7, 30, 90, or 365 days — or set a custom range, and group data points by day, week, or month.

Analytics in the API and CLI

For the first time, your metrics are available outside the app. The new GET /accounts/{accountSlug}/analytics REST endpoint returns the same build and screenshot metrics that power the dashboard, and the CLI wraps it in a single command:

argos analytics --account my-team --from 2026-01-01 --group-by week

You get totals and a per-period series for builds and screenshots — including build outcomes — broken down by project. Add --json when a script, a dashboard, or an AI agent needs to parse the result.

Learn more in the analytics documentation, or explore the analytics endpoint and the argos analytics CLI command.

Vitest SDK

Argos now ships a dedicated Vitest SDK. @argos-ci/vitest brings visual testing to Vitest browser tests — and snapshot diffing of any value to every Vitest test, browser or Node. It's stable and ready for production today.

• argosScreenshot — capture screenshots in your browser tests with the full Argos toolkit: multiple viewports, ARIA snapshots, automatic UI stabilization, tags, and more.
• argosSnapshot — snapshot any value, not just UI: API responses, JSON, generated HTML, Markdown. Objects are serialized automatically, and the file extension controls how Argos renders and diffs them. Works in plain Node tests too — no browser required.
• One plugin — argosVitestPlugin registers both commands in your Vitest config and uploads everything captured to Argos at the end of your CI run.

import { argosScreenshot } from "@argos-ci/vitest";
import { test } from "vitest";
import { render } from "vitest-browser-react";

import { Button } from "./Button";

test("Button", async () => {
  render(<Button>Click me</Button>);
  await argosScreenshot("button");
});

No PNG baselines committed to Git and no --update round-trips: Argos picks the baseline from your Git history, and your team reviews visual changes right on the pull request.

Read the announcement blog post for the full story and a step-by-step setup guide.

👉 Get started in the docs

Collaborative reviews

Reviewing a build used to be a solo, one-shot decision — only the latest review counted, and there was nowhere to talk through what you were seeing. Reviews in Argos are now a place to collaborate. Request the people you need, leave comments pinned to exactly what changed, and resolve the discussion together — all updating in real time.

Every reviewer's decision now counts on its own, so a build reflects the whole team's input instead of just the last person to weigh in. And it's not just people: the CLI now exposes the full review toolkit, so AI agents can read a build, pin comments to the exact screenshots that changed, and submit a complete review — just like a human reviewer.

• Multiple reviewers — request reviewers on a build and track each person's verdict individually, rather than overwriting it with the most recent one.
• Comment on exactly what changed — pin a comment to a precise point on a screenshot, or to a line range inside a text-based snapshot.
• Full discussion threads — reply, @mention teammates, react with emoji, and resolve or reopen threads once a conversation is done.
• Draft reviews — gather your comments into a pending review that stays private until you submit, then notifies everyone at once — GitHub-style.
• A redesigned review dialog — submit from a compact, focused popover with one-press Comment, Reject, and Approve actions.
• Real time, with presence — comments, reactions, resolutions, and review decisions appear live, and presence dots show who's online and their local time.
• Review from the API — every review and comment action is now in the public REST API: dismiss and list reviews, comment CRUD, replies, reactions, and thread resolve.

Comments are written in Markdown with / slash commands and @mentions, drafts persist locally so you never lose a thought, and review notifications now arrive as a single digest instead of one per action.

Learn more in the reviewing a build documentation, see how to review builds with AI agents, or explore the reviews and comments endpoints in the REST API reference.

Configure what Argos ignores

Project ignore behavior is now fully configurable. Turn the ignore feature off entirely, disable auto-ignore, or tune the auto-ignore threshold from project settings. When the feature is off, new builds ignore nothing — and the count of ignored screenshots now shows in the PR comment Details column.

Learn more in the ignore changes documentation.

Start a project without Git

You no longer need to connect GitHub or GitLab to get started. The redesigned New Project page offers two paths side by side: import from a Git provider, or create a project from just a name and link a repository later.

See if a build can be a baseline

Builds now show whether they're eligible to become a baseline for future builds — and, when they're not, why. A new chip explains the criteria at a glance: the build is complete, its tests passed, it's approved or merged, and it isn't a subset.

Learn more in the baseline build documentation.

Account-wide flaky tests

Flaky tests are no longer buried per project. A new Tests tab on your account aggregates active tests across every project you can see, sorted by flakiness, so the noisiest ones surface first.

Learn more in the tests dashboard documentation.

Screenshot actions menu

A new ⋮ menu on the baseline and changes panes lets you copy a screenshot link, copy it as Markdown, or download it — making it easy to reference a screenshot straight in a PR.

Compare non-image files

Argos can now compare more than screenshots. Upload text-based artifacts with the CLI and Argos will match them to baselines, surface changes in builds, and let reviewers inspect diffs alongside visual snapshots.

Use it for API snapshots, generated HTML, Markdown files, CSS output, JavaScript bundles, XML documents, YAML files, JSON fixtures, and plain text files.

• Text artifact diffs: Review changes to JSON, YAML, XML, HTML, Markdown, CSS, JavaScript, and plain text directly in Argos.
• Same baseline workflow: Stable paths let Argos compare each file against its baseline on future builds, just like screenshots.
• CLI upload support: Pass one or more -f / --files globs to argos upload, and include screenshot globs when you want mixed image and text comparisons.

Non-image comparisons are supported through the CLI today.

Learn more in the non-image comparisons documentation.

Deployments

Deployments turn Argos into a host for your static builds. Run argos deploy ./storybook-static and get a unique live URL on every pull request—no extra infrastructure to maintain.

• Preview & production environments: PRs ship to immutable preview URLs; merges to your production branch promote to a stable production domain.
• Stable URLs to share: every deployment exposes an immutable deployment URL, a branch URL that follows the latest build, and—for production—a project-wide domain.
• Access protection: keep previews private to your team while leaving the production domain public, or lock everything behind Argos login.
• Built into the PR comment: deployment links sit next to your Argos visual build, with a commit status you can require in branch protection.

Works with Storybook, Vite, Next.js exports, plain HTML—anything that builds to a static directory.

Learn more in the Deployments documentation.

Secure GitHub Actions authentication

Argos can now authenticate GitHub Actions uploads without storing a long-lived ARGOS_TOKEN secret in your repository.

With GitHub OIDC, each workflow run receives a short-lived identity token signed by GitHub. Argos verifies the token against the linked repository and workflow, then accepts the upload with credentials scoped to that build.

For workflows where GitHub does not issue OIDC tokens, especially pull requests from forks, the SDK falls back to a more secure tokenless flow. Argos verifies the in-progress workflow run through the GitHub API before issuing a short-lived token.

• OIDC where available: Enable GitHub OIDC in Project Settings -> Authentication, add id-token: write to your workflow permissions, and remove ARGOS_TOKEN from the job.
• No long-lived CI secret: Uploads use GitHub-signed identity and short-lived scoped credentials instead of a reusable Argos token.
• Safer tokenless fallback: Forked pull requests and public repositories can still upload without secrets while Argos checks the repository, commit, branch, and workflow run.
• One workflow for every PR: Internal PRs use OIDC, while forked PRs fall back to tokenless automatically when OIDC is unavailable.

Learn more in the GitHub OIDC documentation and the GitHub tokenless documentation.

Build reviews from the CLI

Argos builds can now be inspected and reviewed from the terminal.

Use the new CLI commands to fetch build metadata, list snapshots that still need review, and submit an approval or request changes without leaving your development workflow.

Install the CLI with npm install -D @argos-ci/cli, then see the CLI documentation for authentication, commands, and examples.

argos build get <build>
argos build snapshots <build> --needs-review
argos build review <build> --conclusion approve

Built for humans and agents

The CLI gives developers a fast way to review Argos builds locally, and gives coding agents a structured way to inspect visual changes during pull request reviews.

Agents can fetch build status, read machine-friendly snapshot data, compare visual diffs against the pull request intent, and help catch regressions before they merge.

From a build page, use the new Copy prompt button to start an agent review with the build URL, pull request context, and review guidance already included.

Reviews submitted from the CLI use personal access tokens and respect existing project permissions.

Tag-based filtering

You can now filter screenshots using tags to focus on the parts of a build that matter.

Tags let you quickly isolate relevant screenshots, whether you’re reviewing a specific workflow, a single Storybook story or a particular environment like mobile.

• Automatic and custom tags: Use built-in metadata like viewport, browser or color scheme, or define your own tags in the SDK.
• Test and snapshot tags: Filter based on tags coming from tests or individual screenshots.
• Composable filters: Combine multiple tags to narrow down results with AND logic.

Read more about tags in the Argos documentation.