Configure Argos CI by splitting visual coverage by app or package: each app runs its own Argos visual tests, and those tests belong to the same commit. Choose the Argos integration that matches each app’s test framework. Treat parallel workers inside one app as a separate concern—Argos calls that sharding. The current Monorepos setup guide is the place to confirm exact configuration syntax; the official material available here establishes the setup pattern but not copyable YAML or CLI flags.
How the monorepo setup should be organized
Think of the repository as a set of independently tested apps or packages that share a commit, rather than as one undifferentiated visual-test suite. For each app, identify its test stack and run the matching Argos integration. The monorepo pattern is build splitting: separate Argos visual tests for each package or app, associated with one commit.
As an Amazon Associate I earn from qualifying purchases.
- Inventory the apps and packages. List the parts of the repository that need visual coverage and note the framework each one uses.
- Choose an integration for each app. Argos quickstarts cover Playwright, Vitest, Storybook, Cypress, WebdriverIO and Puppeteer. A generic CLI upload route is listed for other frameworks.
- Split coverage at the app or package boundary. Run each app’s visual tests as its own Argos test contribution while keeping the contributions tied to the shared commit.
- Configure the exact invocation from Argos’s current guide. Check its current monorepo documentation for the precise YAML, CLI flags, project-token arrangement and naming convention. Those details are not established by the official summaries cited here, so avoid copying guessed configuration.
- Run a pull request and verify the result. Confirm that the intended apps contribute visual tests to the same commit and that each contribution uses the expected framework integration.
Choose the integration that fits each app
There is no need to make every app use the same framework integration if the repository contains different stacks. Use the dedicated Argos quickstart corresponding to each app’s test framework; use the CLI upload route when the framework is not among the listed integrations.
Free tools Windows power users keep installed
One-click scans. No signup required.
| App’s test stack | Argos route |
|---|---|
| Playwright | Playwright quickstart |
| Vitest | Vitest quickstart |
| Storybook | Storybook quickstart |
| Cypress | Cypress quickstart |
| WebdriverIO | WebdriverIO quickstart |
| Puppeteer | Puppeteer quickstart |
| Another framework | Generic CLI upload route |
Use Argos’s Monorepos setup guide and documentation index to reach the current instructions. The available official summary does not specify which token or project arrangement to use per app, so verify that detail in the live guide rather than assuming one project token per package or a shared token.
#1 Best Overall
App-level splitting is not the same as sharding
Build splitting organizes visual coverage across apps or packages. Sharding addresses a different problem: dividing one app’s test run across parallel workers and collecting their screenshots into one build. If one app’s suite is slow, consult Argos’s parallel-testing guidance separately; sharding does not replace the monorepo boundary.
- Several apps or packages: split visual tests by app/package and associate them with the same commit.
- One app running on multiple workers: use the sharding pattern so parallel-node screenshots collect into one build.
- Both conditions: first define app-level contributions, then configure sharding within any app that needs parallel execution. Confirm the precise interaction and syntax in the current Argos docs.
GitHub Actions authentication
For GitHub Actions, Argos documents OIDC authentication. Its May 11, 2026 changelog says to enable OIDC in Project Settings → Authentication and set the workflow permission id-token: write. Where GitHub issues OIDC tokens, the changelog says a long-lived ARGOS_TOKEN is not needed. It also describes a tokenless fallback for cases where GitHub does not issue OIDC tokens, especially fork pull requests. Check Argos’s current documentation index and your project’s settings before changing workflow secrets; an older Storybook/GitHub Actions example uses ARGOS_TOKEN and should not be treated as the only current authentication approach.
Storybook apps with themes, viewports or locales
If an app uses Storybook and needs independent baselines for UI variants, Argos Storybook modes can create separate snapshots and isolated baselines for modes such as themes, viewport sizes and locales. Argos announced Story Modes on April 1, 2025. This is a baseline organization choice within a Storybook app, not a substitute for splitting distinct repository apps. Consult the Storybook integration docs linked from the Argos docs index for current setup details.
Branch behavior and optional previews
Argos’s October 8, 2024 multi-branches announcement says base-branch inference and auto-approved branches are applied automatically, with optional project-level customization. Review the current project settings if your team needs different branch behavior.
Deployment previews are adjacent rather than required: the monorepo visual-test pattern is about collecting app-level visual tests for a commit. A preview deployment may be useful in a workflow, but it is not established as a prerequisite for build splitting.
What to verify before merging the configuration
- Every app that needs visual coverage has an identified framework integration or a CLI upload path.
- The app-level runs are tied to the same commit as intended, rather than being treated as one app’s worker shards.
- Any sharded app uses the separate parallel-testing setup and gathers its worker screenshots into one build.
- GitHub Actions permissions and project authentication match the current Argos guidance, including fork pull-request behavior.
- Storybook variants that need independent baselines are represented as modes rather than accidentally sharing one baseline.
Common setup problems and how to resolve them
An app does not appear in the expected build
Check that the app’s CI job actually runs its selected integration and that its result is associated with the intended commit. Then compare the job invocation and app/project arrangement with the current monorepo guide. The available official summary does not establish exact job names or flags.
Parallel workers produce separate results instead of one build
This is an app-level versus shard-level configuration mismatch. Use the parallel-testing guidance for the app’s workers and verify the supported collection behavior; do not assume that monorepo build splitting automatically combines worker outputs.
GitHub Actions authentication fails on a pull request
Check whether the workflow has id-token: write, whether OIDC is enabled in Project Settings → Authentication, and whether that GitHub event issues an OIDC token. For events such as fork pull requests where it may not, follow Argos’s documented tokenless fallback behavior rather than assuming OIDC is always present.
Theme or viewport snapshots overwrite one another
For Storybook variants intended to have independent baselines, use the documented Storybook modes approach and verify that each desired global combination is represented as a distinct mode.
A copied configuration example relies only on ARGOS_TOKEN
That may reflect older guidance. Compare it with Argos’s May 11, 2026 OIDC announcement and the current authentication settings; use a long-lived token only when the current setup requires it.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Or skip the browser setup
Argos is for visual testing and baselines; ScreenshotNeo is an alternative for taking website screenshots through an API, not a replacement for Argos’s CI comparison workflow. If the task is simply to capture a page, one GET request can return an image or PDF. See the ScreenshotNeo API documentation.
Recommended Free Tools
curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpScreenshotNeo accepts cookie or consent banners and removes more than 60 known consent platforms, newsletter popups and chat widgets before capture; each step can be turned off. Bot checks, blank pages, timeouts, failed loads and cache hits are not billed, and response headers identify the page verdict and billing status. It also has an MCP server with screenshot, page-info and PDF tools for AI agents. The free plan includes 1,000 shots a month with no card; paid plans start at $5 for 3,000 shots.
Sign up for 1,000 free screenshots a month—no card required.
Best Value
Frequently Asked Questions
Does every app in the monorepo need to use the same testing framework?
No. The setup pattern is per app or package, so different apps can use their own supported Argos integration.
Does Argos monorepo setup require a deployment preview?
No such requirement is established in the monorepo setup summary; deployment previews are an adjacent, optional workflow.
The Tool Desk
Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
