Changelog

Media sharing

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

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

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

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 MCP — argos 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 settings — Settings › 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

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