Changelog

New updates and improvements to Argos.

Custom domains

Several domains resolving to one production deployment served over HTTPS

A generated deployment URL is fine for a reviewer and awkward for everyone else. Sending a designer your Storybook, or support a docs preview, meant handing them an argos-ci.live hostname nobody recognises. Custom domains put production deployments on a domain you own.

  • One DNS record — point a CNAME at cname.argos-ci.live. That record is both the routing and the proof you own the domain, so there is no TXT record to add and nothing to verify by hand.
  • Certificates handled — Argos requests and installs the TLS certificate as soon as the domain resolves. Nothing to upload, nothing to renew.
  • Always the current production deployment — the domain follows production the way the internal one does. Preview deployments keep their own per-deployment and branch URLs.
  • The link GitHub shows — once a domain is live, the commit status and the pull request comment point at it instead of the generated URL.
  • A status worth reading — each domain says whether it is waiting on DNS, issuing a certificate, or live, and shows the exact record to create until it resolves.
storybook.acme.com.  CNAME  cname.argos-ci.live.

Root domains are the one wrinkle: most DNS providers refuse a CNAME on an apex, so use an ALIAS or ANAME record pointing at the same value, or point a subdomain at Argos instead.

Add a domain from Settings → Deployments → Domains. Custom domains are included in paid plans. Learn more in the URLs and domains documentation.

Media sharing

A screenshot travelling from a terminal to a pull request comment

GitHub has no public API for comment attachments, so an agent — or a CI job — has no way to put a screenshot in the pull request it just opened. Media sharing fixes that: upload an image or a video on its own, no build required, and get a stable share link with Markdown ready to paste.

  • Staged on a branch, published by Argos — upload with --branch while the work happens. When a pull request opens for that branch, Argos publishes everything staged there and posts a single managed comment.
  • Re-upload, same link — a media is an identity and every upload is a version of it. The share URL never changes, and the version a reviewer commented on survives in the history.
  • Before/after pairs — name two files -before and -after and they share one comment row, and a share page comparing both sides with synced pan and zoom.
  • Feedback agents can act on — reviewers pin comments to a point on the image; an agent reads the coordinates back with argos media comment list, fixes, replies, and resolves.
  • On the meter you already have — an image counts as 1 screenshot, a video as 25. Retention follows your plan: 30 days on Hobby, 1 year on Pro.

It works from the CLI, the Node.js SDK, the REST API, and the MCP server — and the argos-upload skill teaches your coding agent when and how to use it.

npx argos media upload checkout-before.png checkout-after.png --branch feat/checkout

Learn more in the media sharing documentation, or read why we think agents should show their work on the blog.

Management API

Team, project, and automation settings driven from an API and a terminal

The Argos API could read your builds and review them. Everything else — who is on the team, how a project is configured, which automations fire — lived only in the app. The management API closes that gap with thirty-four new endpoints.

  • Teams — list members and change their role, send and cancel invites, rotate the invite link, open a team to a verified email domain.
  • Projects — read and update every setting, transfer a project to another account, grant contributors access, list deployments, set the deployment domain.
  • Automations — list, create, replace, and deactivate the rules that run when a build event matches.
  • Tests and reviews — a project's tests flakiest first, the changes it currently ignores, and the reviewers requested on a build.
  • Plan and usage — screenshot consumption against the plan for the current billing period, so you see an overage coming.

The CLI grew the matching commands, including a project group that changes one setting at a time and an account group for everything team-shaped:

argos test list --project acme/web --limit 20
argos project update --project acme/web --summary-check auto --auto-ignore-after 3
argos account member list --account acme

Thirty-four endpoints, thirty-four agent tools

The MCP server derives its tools from the API, so it went from 37 tools to 71 the moment these shipped — no client update needed. An agent can now onboard a teammate, tune a project's flaky-change settings, or ask who still owes a review, with the same OAuth scopes that govern the API. Scopes are unchanged: account:admin covers team administration, projects:write project configuration, reviews:write review requests.

Learn more in the API reference and the CLI documentation.

Discord notifications

An Argos build notification posted in a Discord channel

Argos now posts build notifications to Discord. Plenty of engineering teams run their day in Discord rather than Slack — now visual changes land there too, without anyone leaving the server to check a build.

  • Embeds, not link dumps — build status, project, commit, branch, pull request, and a direct link to the build.
  • Driven by automations — pick the events that trigger a notification, add conditions like "Build type is check", and choose the channel to post in.
  • Several channels per team — connect as many as you need, each with its own name and webhook URL.
  • Test before you trust it — send a test message from the channel's actions menu, or fire a real notification from the automation form with Send Test Notification.

Connect a channel in two steps

There's no bot to install in your server. In Discord, create a webhook on the channel you want to notify — Edit Channel › Integrations › Webhooks › New Webhook — then paste the URL into your team's Settings › Integrations. Argos posts under the name Argos whatever you called the webhook.

Because the connection is outbound only, Argos never reads messages in your server. Only team admins can add, test, or remove channels, and the webhook token stays masked as *** for everyone else — it's a secret, and anyone holding it can post to that channel.

Discord notifications are configured at team level and available on Pro and Enterprise plans. They join Slack and Microsoft Teams as notification targets, all sharing the same automations engine.

👉 Set up Discord notifications in the docs

Test comments

Test comments in Argos

A flaky test outlives the build that surfaced it. Until now the only place to talk about one was a build review — a conversation that scrolls away with the build, while the test keeps failing for weeks. Test comments give every test its own thread, on the test page where you investigate it.

  • Comment on the test, not the run — the Activity feed on a test page is for what belongs to the test itself: "flaky since we added the carousel", "waiting on the upstream fix", "safe to ignore until Q3".
  • Threads, mentions, reactions — reply to start a thread, @mention a teammate, react with emoji, and resolve a thread once it's settled. Comments are Markdown, with / slash commands for formatting.
  • Posted immediately — unlike a build comment, there's no pending review to batch it into. Everything updates live for everyone on the page.
  • Follow a test — the bell in the Activity header subscribes you to new comments. Commenting follows it for you.
  • From the CLI, API, and MCPargos test comment mirrors the build comment toolkit: list, create, edit, resolve, react, subscribe, and the rest.
argos test comment create <testId> --project team/project --body "Flaky since the carousel landed."

Hand the flakiness to an AI agent

The Fix with AI card on a test page gives you a prompt to paste into Claude Code, Codex, Cursor, or any agent working in your repository. It names the test, carries the flakiness Argos measured, and tells the agent how to pull the recurring changes and their screenshots for itself — so it hunts for the animation, the unfrozen clock, or the unordered data instead of guessing. The card expands on its own when a test looks flaky, and Preview the prompt shows you what you're copying.

A test, its metrics, and its distinct changes are now in the public API too, which is what the agent reads:

argos test get <testId> --json
argos test changes <testId> --json

The same data is available as the getTest and listTestChanges MCP tools. Read more in Fix flaky tests with AI agents, or see the whole test page — metrics, change history, and discussion in one place.

Sign in with a passkey

Argos now supports passkeys. Sign in with Touch ID, Face ID, Windows Hello, your phone's screen lock, or a hardware key like a YubiKey — no password, nothing to phish, nothing to leak in a breach.

  • No email step — select Continue with Passkey on the login page and your device lists the Argos accounts it holds a key for.
  • One per device, or a phone for all of them — register as many passkeys as you like, and use a passkey on your phone to sign in on a computer that has none via a QR code.
  • Manage them in settingsSettings › Authentication › Passkeys shows every key with when it was created and last used, and lets you rename or delete it.

Passkeys are available on every plan and sit alongside your existing login methods rather than replacing them. Note that a passkey signs you into Argos but does not satisfy a team that enforces SAML SSO.

👉 Add a passkey in the docs

Ignored changes on the test page

The changes explorer now has an All / Ignored toggle, so you can see what Argos is skipping for a test and reconsider it. Like the period selector, the filter lives in the URL — a link you share opens on the same view. See Ignored changes.

Fallback baselines

A screenshot with no match in the baseline build is reported as added, which is the wrong answer when it's really a variant of an existing one. The new baseName option takes a list of names to compare against, in priority order:

await argosScreenshot(page, "home-variant-b", {
  baseName: ["home-variant-b", "home"],
});

Argos compares against the first name that exists in the baseline, so A/B variants and themed screenshots show a real diff on their first run. Learn more about fallback baselines.

Also in this release: the account and project Tests lists load significantly faster, Playwright warns when the recommended Chromium launch options are missing, and subset builds no longer count removed snapshots as changes.

Microsoft Teams notifications

An Argos build notification posted in a Microsoft Teams channel

Argos now posts build notifications to Microsoft Teams. Connect a channel once and your team sees visual changes where it already works, without leaving Teams to check a build.

  • Adaptive cards — build status, project, screenshot counts, commit, branch, and a View build button.
  • Same automations as Slack — pick the events that trigger a notification, add conditions, and choose the channel to post in.
  • Several channels per team — connect as many as you need, each with its own name and webhook.

Connect a channel in two steps

No app to install in your Microsoft 365 tenant: in Teams, add a Workflows › Send webhook alerts to a channel flow to the channel you want to notify, then paste the URL it gives you into your team's Settings › Integrations.

Each connected channel shows its webhook URL, and its actions menu lets you send a test message, copy the URL, or disconnect the channel. Only team admins can manage them, and the URL's signature stays masked for everyone else.

👉 Set up Microsoft Teams notifications in the docs

SAML SSO available as an add-on

SAML SSO

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

An AI agent connected to Argos build reviews through MCP

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

Redesigned Argos analytics dashboard

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

Vitest test run flowing into Argos visual diffs

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 pluginargosVitestPlugin 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