{
  "doc": {
    "id": "cloud/features/smart-orchestration/parallelization",
    "title": "Parallelization",
    "description": "Run tests in parallel across multiple machines to save time and money in Continuous Integration.",
    "section": "cloud",
    "source_path": "/llm/markdown/cloud/features/smart-orchestration/parallelization.md",
    "version": "48b03b5502f7aea1d0454750cce208f775403542",
    "updated_at": "2026-05-20T19:00:20.270Z",
    "headings": [
      {
        "id": "cloud/features/smart-orchestration/parallelization#parallelization",
        "text": "Parallelization",
        "level": 1
      },
      {
        "id": "cloud/features/smart-orchestration/parallelization#what-youll-learn",
        "text": "What you'll learn",
        "level": 5
      },
      {
        "id": "cloud/features/smart-orchestration/parallelization#splitting-up-your-test-suite",
        "text": "Splitting up your test suite",
        "level": 2
      },
      {
        "id": "cloud/features/smart-orchestration/parallelization#turning-on-parallelization",
        "text": "Turning on parallelization",
        "level": 2
      },
      {
        "id": "cloud/features/smart-orchestration/parallelization#ci-parallelization-interactions",
        "text": "CI parallelization interactions",
        "level": 2
      },
      {
        "id": "cloud/features/smart-orchestration/parallelization#parallelization-process",
        "text": "Parallelization process",
        "level": 3
      },
      {
        "id": "cloud/features/smart-orchestration/parallelization#example",
        "text": "Example",
        "level": 2
      },
      {
        "id": "cloud/features/smart-orchestration/parallelization#without-parallelization",
        "text": "Without parallelization",
        "level": 3
      },
      {
        "id": "cloud/features/smart-orchestration/parallelization#with-parallelization",
        "text": "With parallelization",
        "level": 3
      },
      {
        "id": "cloud/features/smart-orchestration/parallelization#grouping-test-runs",
        "text": "Grouping test runs",
        "level": 2
      },
      {
        "id": "cloud/features/smart-orchestration/parallelization#grouping-by-browser",
        "text": "Grouping by browser",
        "level": 3
      },
      {
        "id": "cloud/features/smart-orchestration/parallelization#grouping-to-label-parallelization",
        "text": "Grouping to label parallelization",
        "level": 3
      },
      {
        "id": "cloud/features/smart-orchestration/parallelization#grouping-by-spec-context",
        "text": "Grouping by spec context",
        "level": 3
      },
      {
        "id": "cloud/features/smart-orchestration/parallelization#linking-ci-machines-for-parallelization-or-grouping",
        "text": "Linking CI machines for parallelization or grouping",
        "level": 2
      },
      {
        "id": "cloud/features/smart-orchestration/parallelization#ci-build-id-environment-variables-by-provider",
        "text": "CI Build ID environment variables by provider",
        "level": 3
      },
      {
        "id": "cloud/features/smart-orchestration/parallelization#run-completion-delay",
        "text": "Run completion delay",
        "level": 2
      },
      {
        "id": "cloud/features/smart-orchestration/parallelization#visualizing-parallelization-and-groups-in-cypress-cloud",
        "text": "Visualizing parallelization and groups in Cypress Cloud",
        "level": 2
      },
      {
        "id": "cloud/features/smart-orchestration/parallelization#timeline-view",
        "text": "Timeline View",
        "level": 3
      },
      {
        "id": "cloud/features/smart-orchestration/parallelization#bar-chart-view",
        "text": "Bar Chart View",
        "level": 3
      },
      {
        "id": "cloud/features/smart-orchestration/parallelization#machines-view",
        "text": "Machines View",
        "level": 3
      },
      {
        "id": "cloud/features/smart-orchestration/parallelization#next-steps",
        "text": "Next Steps",
        "level": 2
      }
    ]
  },
  "chunks": [
    {
      "id": "cloud/features/smart-orchestration/parallelization#what-youll-learn",
      "doc_id": "cloud/features/smart-orchestration/parallelization",
      "heading": "What you'll learn",
      "heading_level": 5,
      "content_markdown": "##### What you'll learn\n\n*   How Cypress balances spec files across multiple machines\n*   How to run tests in parallel across multiple machines\n*   How to group test runs and why you might want to\n*   How to visualize parallelization and groups in Cypress Cloud\n\nIf your project has a large number of tests, it can take a long time for tests to complete running serially on one machine. Running tests in parallel across many virtual machines can save your team time and money when running tests in Continuous Integration (CI).\n\nCypress can run recorded tests in parallel across multiple machines. While parallel tests can also technically run on a single machine, we do not recommend it since this machine would require significant resources to run your tests efficiently.\n\nThis guide assumes you already have your project running and [recording](/llm/markdown/cloud/get-started/setup.md#Setup) within Continuous Integration. If you have not set up your project yet, check out our [Continuous Integration guide](/llm/markdown/app/continuous-integration/overview.md). If you are running or planning to run tests across multiple browsers (Firefox, Chrome, or Edge), we also recommend checking out our [Cross Browser Testing guide](/llm/markdown/app/guides/cross-browser-testing.md) for helpful CI strategies when using parallelization.\n",
      "section": "cloud",
      "anchors": [
        "what-youll-learn"
      ],
      "path": "/llm/json/chunked/cloud/features/smart-orchestration/parallelization.json",
      "token_estimate": 255
    },
    {
      "id": "cloud/features/smart-orchestration/parallelization#splitting-up-your-test-suite",
      "doc_id": "cloud/features/smart-orchestration/parallelization",
      "heading": "Splitting up your test suite",
      "heading_level": 2,
      "content_markdown": "## Splitting up your test suite\n\nCypress' parallelization strategy is file-based, so in order to utilize parallelization, your tests will need to be split across separate files.\n\nCypress will assign each spec file to an available machine based on our [balance strategy](/llm/markdown/cloud/features/smart-orchestration/load-balancing.md#Balance-strategy). Due to this balance strategy, the run order of the spec files is not guaranteed when parallelized.\n",
      "section": "cloud",
      "anchors": [
        "splitting-up-your-test-suite"
      ],
      "path": "/llm/json/chunked/cloud/features/smart-orchestration/parallelization.json",
      "token_estimate": 79
    },
    {
      "id": "cloud/features/smart-orchestration/parallelization#turning-on-parallelization",
      "doc_id": "cloud/features/smart-orchestration/parallelization",
      "heading": "Turning on parallelization",
      "heading_level": 2,
      "content_markdown": "## Turning on parallelization\n\n1.  Refer to your CI provider's documentation on how to set up multiple machines to run in your CI environment.\n    \n2.  Once multiple machines are available within your CI environment, you can pass the [\\--parallel](/llm/markdown/app/references/command-line.md#cypress-run-parallel) key to [cypress run](/llm/markdown/app/references/command-line.md#cypress-run) to have your recorded tests parallelized.\n    \n\n```\ncypress run --record --key=abc123 --parallel\n```\n\nRunning tests in parallel requires the [`--record` flag](/llm/markdown/app/references/command-line.md#cypress-run) be passed. This ensures Cypress can properly collect the data needed to parallelize future runs. This also gives you the full benefit of seeing the results of your parallelized tests in [Cypress Cloud](/llm/markdown/cloud/get-started/introduction.md). If you have not set up your project to record, check out our [setup guide](/llm/markdown/cloud/get-started/setup.md#Setup).\n",
      "section": "cloud",
      "anchors": [
        "turning-on-parallelization"
      ],
      "path": "/llm/json/chunked/cloud/features/smart-orchestration/parallelization.json",
      "token_estimate": 149
    },
    {
      "id": "cloud/features/smart-orchestration/parallelization#ci-parallelization-interactions",
      "doc_id": "cloud/features/smart-orchestration/parallelization",
      "heading": "CI parallelization interactions",
      "heading_level": 2,
      "content_markdown": "## CI parallelization interactions\n\nDuring parallelization mode, [Cypress Cloud](/llm/markdown/cloud/get-started/introduction.md) interacts with your CI machines to orchestrate the parallelization of a test run via [load-balancing](/llm/markdown/cloud/features/smart-orchestration/load-balancing.md) of specs across available CI machines by the following process:\n\n1.  CI machines contact [Cypress Cloud](/llm/markdown/cloud/get-started/introduction.md) to indicate which spec files to run in the project.\n2.  A machine opts in to receiving a spec file to run by contacting Cypress.\n3.  Upon receiving requests from a CI machine, Cypress calculates the estimated duration to test each spec file.\n4.  Based on these estimations, Cypress distributes ([load-balances](/llm/markdown/cloud/features/smart-orchestration/load-balancing.md)) spec files one-by-one to each available machine in a way that minimizes overall test run time.\n5.  As each CI machine finishes running its assigned spec file, more spec files are distributed to it. This process repeats until all spec files are complete.\n6.  Upon completion of all spec files, Cypress [waits for a configurable amount of time](#Run-completion-delay) before considering the test run as fully complete. This is done to better support [grouping of runs](#Grouping-test-runs).\n\nIn short: each Cypress instance sends a list of the spec files to Cypress Cloud, which sends back one spec at a time to each application to run.\n\n### Parallelization process\n",
      "section": "cloud",
      "anchors": [
        "ci-parallelization-interactions"
      ],
      "path": "/llm/json/chunked/cloud/features/smart-orchestration/parallelization.json",
      "token_estimate": 263
    },
    {
      "id": "cloud/features/smart-orchestration/parallelization#example",
      "doc_id": "cloud/features/smart-orchestration/parallelization",
      "heading": "Example",
      "heading_level": 2,
      "content_markdown": "## Example\n\nThe examples below are from a run of our [Kitchen Sink Example](https://github.com/cypress-io/cypress-example-kitchensink) project. You can see the results of this run on [Cypress Cloud](https://cloud.cypress.io/projects/4b7344/runs/2929/specs).\n\n### Without parallelization\n\nIn this example, a single machine runs a job named `1x-electron`, defined in the project's [circle.yml](https://github.com/cypress-io/cypress-example-kitchensink/blob/aabb10cc1bb9dee88e1bf28e0af5e9661427ee7a/circle.yml#L41) file. Cypress runs all 19 spec files one by one alphabetically in this job. It takes **1:51** to complete all of the tests.\n\n```\n1x-electron, Machine #1---------------------------- actions.cy.js (14s)-- aliasing.cy.js (1s)-- assertions.cy.js (1s)-- connectors.cy.js (2s)-- cookies.cy.js (2s)-- cypress_api.cy.js (3s)-- files.cy.js (2s)-- local_storage.cy.js (1s)-- location.cy.js (1s)-- misc.cy.js (4s)-- navigation.cy.js (3s)-- network_requests.cy.js (3s)-- querying.cy.js (1s)-- spies_stubs_clocks.cy.js (1s)-- traversal.cy.js (4s)-- utilities.cy.js (3s)-- viewport.cy.js (3s)-- waiting.cy.js (5s)-- window.cy.js (1s)\n```\n\nNotice that when adding up the spec's run times (**0:55**), they add up to less than the total time for the run to complete (**1:51**) . There is extra time in the run for each spec: starting the browser, encoding and uploading the video to the dashboard, requesting the next spec to run.\n\n### With parallelization\n\nWhen we run the same tests with parallelization, Cypress uses its [load balance strategy](/llm/markdown/cloud/features/smart-orchestration/load-balancing.md#Balance-strategy) to order to specs to run based on the spec's previous run history. During the same CI run as above, we ran _all_ tests again, but this time with parallelization across 2 machines. This job was named `2x-electron` in the project's [circle.yml](https://github.com/cypress-io/cypress-example-kitchensink/blob/aabb10cc1bb9dee88e1bf28e0af5e9661427ee7a/circle.yml#L53) file and it finished in **59 seconds**.\n\n```\n2x-electron, Machine #1, 9 specs          2x-electron, Machine #2, 10 specs--------------------------------          ------------------------------------- actions.cy.js (14s)                    -- waiting.cy.js (6s)-- traversal.cy.js (4s)                   -- navigation.cy.js (3s)-- misc.cy.js (4s)                        -- utilities.cy.js (3s)-- cypress_api.cy.js (4s)                 -- viewport.cy.js (4s)-- cookies.cy.js (3s)                     -- network_requests.cy.js (3s)-- files.cy.js (3s)                       -- connectors.cy.js (2s)-- location.cy.js (2s)                    -- assertions.cy.js (1s)-- querying.cy.js (2s)                    -- aliasing.cy.js (1s)-- location.cy.js (1s)                    -- spies_stubs_clocks.cy.js (1s)                                          -- window.cy.js (1s)\n```\n\nThe difference in running times and machines used is very clear when looking at the [Machines View](#Machines-View) on Cypress Cloud. Notice how the run parallelized across 2 machines automatically ran all specs based on their duration, while the run without parallelization did not.\n\nParallelizing our tests across 2 machines saved us almost 50% of the total run time, and we can further decrease the build time by adding more machines.\n",
      "section": "cloud",
      "anchors": [
        "example"
      ],
      "path": "/llm/json/chunked/cloud/features/smart-orchestration/parallelization.json",
      "token_estimate": 481
    },
    {
      "id": "cloud/features/smart-orchestration/parallelization#without-parallelization",
      "doc_id": "cloud/features/smart-orchestration/parallelization",
      "heading": "Without parallelization",
      "heading_level": 3,
      "content_markdown": "### Without parallelization\n\nIn this example, a single machine runs a job named `1x-electron`, defined in the project's [circle.yml](https://github.com/cypress-io/cypress-example-kitchensink/blob/aabb10cc1bb9dee88e1bf28e0af5e9661427ee7a/circle.yml#L41) file. Cypress runs all 19 spec files one by one alphabetically in this job. It takes **1:51** to complete all of the tests.\n\n```\n1x-electron, Machine #1---------------------------- actions.cy.js (14s)-- aliasing.cy.js (1s)-- assertions.cy.js (1s)-- connectors.cy.js (2s)-- cookies.cy.js (2s)-- cypress_api.cy.js (3s)-- files.cy.js (2s)-- local_storage.cy.js (1s)-- location.cy.js (1s)-- misc.cy.js (4s)-- navigation.cy.js (3s)-- network_requests.cy.js (3s)-- querying.cy.js (1s)-- spies_stubs_clocks.cy.js (1s)-- traversal.cy.js (4s)-- utilities.cy.js (3s)-- viewport.cy.js (3s)-- waiting.cy.js (5s)-- window.cy.js (1s)\n```\n\nNotice that when adding up the spec's run times (**0:55**), they add up to less than the total time for the run to complete (**1:51**) . There is extra time in the run for each spec: starting the browser, encoding and uploading the video to the dashboard, requesting the next spec to run.\n",
      "section": "cloud",
      "anchors": [
        "without-parallelization"
      ],
      "path": "/llm/json/chunked/cloud/features/smart-orchestration/parallelization.json",
      "token_estimate": 184
    },
    {
      "id": "cloud/features/smart-orchestration/parallelization#with-parallelization",
      "doc_id": "cloud/features/smart-orchestration/parallelization",
      "heading": "With parallelization",
      "heading_level": 3,
      "content_markdown": "### With parallelization\n\nWhen we run the same tests with parallelization, Cypress uses its [load balance strategy](/llm/markdown/cloud/features/smart-orchestration/load-balancing.md#Balance-strategy) to order to specs to run based on the spec's previous run history. During the same CI run as above, we ran _all_ tests again, but this time with parallelization across 2 machines. This job was named `2x-electron` in the project's [circle.yml](https://github.com/cypress-io/cypress-example-kitchensink/blob/aabb10cc1bb9dee88e1bf28e0af5e9661427ee7a/circle.yml#L53) file and it finished in **59 seconds**.\n\n```\n2x-electron, Machine #1, 9 specs          2x-electron, Machine #2, 10 specs--------------------------------          ------------------------------------- actions.cy.js (14s)                    -- waiting.cy.js (6s)-- traversal.cy.js (4s)                   -- navigation.cy.js (3s)-- misc.cy.js (4s)                        -- utilities.cy.js (3s)-- cypress_api.cy.js (4s)                 -- viewport.cy.js (4s)-- cookies.cy.js (3s)                     -- network_requests.cy.js (3s)-- files.cy.js (3s)                       -- connectors.cy.js (2s)-- location.cy.js (2s)                    -- assertions.cy.js (1s)-- querying.cy.js (2s)                    -- aliasing.cy.js (1s)-- location.cy.js (1s)                    -- spies_stubs_clocks.cy.js (1s)                                          -- window.cy.js (1s)\n```\n\nThe difference in running times and machines used is very clear when looking at the [Machines View](#Machines-View) on Cypress Cloud. Notice how the run parallelized across 2 machines automatically ran all specs based on their duration, while the run without parallelization did not.\n\nParallelizing our tests across 2 machines saved us almost 50% of the total run time, and we can further decrease the build time by adding more machines.\n",
      "section": "cloud",
      "anchors": [
        "with-parallelization"
      ],
      "path": "/llm/json/chunked/cloud/features/smart-orchestration/parallelization.json",
      "token_estimate": 263
    },
    {
      "id": "cloud/features/smart-orchestration/parallelization#grouping-test-runs",
      "doc_id": "cloud/features/smart-orchestration/parallelization",
      "heading": "Grouping test runs",
      "heading_level": 2,
      "content_markdown": "## Grouping test runs\n\nMultiple [cypress run](/llm/markdown/app/references/command-line.md#cypress-run) calls can be labeled and associated to a **single** run by passing in the [`--group <name>` flag](/llm/markdown/app/references/command-line.md#cypress-run-group-lt-name-gt), where `name` is an arbitrary reference label. The group name must be unique within the associated test run.\n\nFor multiple runs to be grouped into a single run, it is required for CI machines to share a common CI build ID environment variable. Typically these CI machines will run in parallel or within the same build workflow or pipeline, but **it is not required to use Cypress parallelization to group runs**. Grouping of runs can be utilized independently of Cypress parallelization.\n\n**Cross Browser Testing**\n\nGrouping test runs with or without parallelization is a useful mechanism when implementing a CI strategy for cross browser testing. Check out the [Cross Browser Testing guide](/llm/markdown/app/guides/cross-browser-testing.md) to learn more.\n\n### Grouping by browser\n\nYou can test your application against different browsers and view the results under a single run within Cypress Cloud. Below, we name our groups the same name as the browser being tested:\n\nThe first group can be called `Windows/Chrome 69`.\n\n```\ncypress run --record --group Windows/Chrome-69 --browser chrome\n```\n\nThe second group can be called `Mac/Chrome 70`.\n\n```\ncypress run --record --group Mac/Chrome-70 --browser chrome\n```\n\nThe third group can be called `Linux/Electron`. _Electron is the default browser used in Cypress runs_.\n\n```\ncypress run --record --group Linux/Electron\n```\n\n### Grouping to label parallelization\n\nWe also have the power of Cypress parallelization with our groups. For the sake of demonstration, let's run a group to test against Chrome with 2 machines, a group to test against Electron with 4 machines, and another group to test against Electron again, but only with one machine:\n\n```\ncypress run --record --group 1x-electron\n```\n\n```\ncypress run --record --group 2x-chrome --browser chrome --parallel\n```\n\n```\ncypress run --record --group 4x-electron --parallel\n```\n\nThe `1x`, `2x`, `4x` group prefix used here is an adopted convention to indicate the level of parallelism for each run, and _is not required or essential_.\n\nThe number of machines dedicated for each `cypress run` call is based on your CI configuration for the project.\n\nLabeling these groups in this manner helps up later when we review our test runs in Cypress Cloud, as shown below:\n\n### Grouping by spec context\n\nLet's say you have an application that has a _customer facing portal_, _guest facing portal_ and an _administration facing portal_. You could organize and test these three parts of your application within the same run:\n\nOne group can be called `package/admin`:\n\n```\ncypress run --record --group package/admin --spec 'cypress/e2e/packages/admin/**/*'\n```\n\nAnother can be called `package/customer`:\n\n```\ncypress run --record --group package/customer --spec 'cypress/e2e/packages/customer/**/*'\n```\n\nThe last group can be called `package/guest`:\n\n```\ncypress run --record --group package/guest --spec 'cypress/e2e/packages/guest/**/*'\n```\n\nThis pattern is especially useful for projects in a monorepo. Each segment of the monorepo can be assigned its own group, and larger segments can be parallelized to speed up their testing.\n",
      "section": "cloud",
      "anchors": [
        "grouping-test-runs"
      ],
      "path": "/llm/json/chunked/cloud/features/smart-orchestration/parallelization.json",
      "token_estimate": 659
    },
    {
      "id": "cloud/features/smart-orchestration/parallelization#grouping-by-browser",
      "doc_id": "cloud/features/smart-orchestration/parallelization",
      "heading": "Grouping by browser",
      "heading_level": 3,
      "content_markdown": "### Grouping by browser\n\nYou can test your application against different browsers and view the results under a single run within Cypress Cloud. Below, we name our groups the same name as the browser being tested:\n\nThe first group can be called `Windows/Chrome 69`.\n\n```\ncypress run --record --group Windows/Chrome-69 --browser chrome\n```\n\nThe second group can be called `Mac/Chrome 70`.\n\n```\ncypress run --record --group Mac/Chrome-70 --browser chrome\n```\n\nThe third group can be called `Linux/Electron`. _Electron is the default browser used in Cypress runs_.\n\n```\ncypress run --record --group Linux/Electron\n```\n",
      "section": "cloud",
      "anchors": [
        "grouping-by-browser"
      ],
      "path": "/llm/json/chunked/cloud/features/smart-orchestration/parallelization.json",
      "token_estimate": 124
    },
    {
      "id": "cloud/features/smart-orchestration/parallelization#grouping-to-label-parallelization",
      "doc_id": "cloud/features/smart-orchestration/parallelization",
      "heading": "Grouping to label parallelization",
      "heading_level": 3,
      "content_markdown": "### Grouping to label parallelization\n\nWe also have the power of Cypress parallelization with our groups. For the sake of demonstration, let's run a group to test against Chrome with 2 machines, a group to test against Electron with 4 machines, and another group to test against Electron again, but only with one machine:\n\n```\ncypress run --record --group 1x-electron\n```\n\n```\ncypress run --record --group 2x-chrome --browser chrome --parallel\n```\n\n```\ncypress run --record --group 4x-electron --parallel\n```\n\nThe `1x`, `2x`, `4x` group prefix used here is an adopted convention to indicate the level of parallelism for each run, and _is not required or essential_.\n\nThe number of machines dedicated for each `cypress run` call is based on your CI configuration for the project.\n\nLabeling these groups in this manner helps up later when we review our test runs in Cypress Cloud, as shown below:\n",
      "section": "cloud",
      "anchors": [
        "grouping-to-label-parallelization"
      ],
      "path": "/llm/json/chunked/cloud/features/smart-orchestration/parallelization.json",
      "token_estimate": 195
    },
    {
      "id": "cloud/features/smart-orchestration/parallelization#grouping-by-spec-context",
      "doc_id": "cloud/features/smart-orchestration/parallelization",
      "heading": "Grouping by spec context",
      "heading_level": 3,
      "content_markdown": "### Grouping by spec context\n\nLet's say you have an application that has a _customer facing portal_, _guest facing portal_ and an _administration facing portal_. You could organize and test these three parts of your application within the same run:\n\nOne group can be called `package/admin`:\n\n```\ncypress run --record --group package/admin --spec 'cypress/e2e/packages/admin/**/*'\n```\n\nAnother can be called `package/customer`:\n\n```\ncypress run --record --group package/customer --spec 'cypress/e2e/packages/customer/**/*'\n```\n\nThe last group can be called `package/guest`:\n\n```\ncypress run --record --group package/guest --spec 'cypress/e2e/packages/guest/**/*'\n```\n\nThis pattern is especially useful for projects in a monorepo. Each segment of the monorepo can be assigned its own group, and larger segments can be parallelized to speed up their testing.\n",
      "section": "cloud",
      "anchors": [
        "grouping-by-spec-context"
      ],
      "path": "/llm/json/chunked/cloud/features/smart-orchestration/parallelization.json",
      "token_estimate": 156
    },
    {
      "id": "cloud/features/smart-orchestration/parallelization#linking-ci-machines-for-parallelization-or-grouping",
      "doc_id": "cloud/features/smart-orchestration/parallelization",
      "heading": "Linking CI machines for parallelization or grouping",
      "heading_level": 2,
      "content_markdown": "## Linking CI machines for parallelization or grouping\n\nA CI build ID is used to associate multiple CI machines to one test run. This identifier is based on environment variables that are unique to each CI build, and vary based on CI provider. Cypress has out-of-the-box support for most of the commonly-used CI providers, so you would typically not need to directly set the CI build ID via the [`--ci-build-id` flag](/llm/markdown/app/references/command-line.md#cypress-run-ci-build-id-lt-id-gt).\n\n### CI Build ID environment variables by provider\n\nCypress currently uses the following CI environment variables to determine a CI build ID for a test run:\n\n| Provider | Environment Variable |\n| --- | --- |\n| AppVeyor | `APPVEYOR_BUILD_NUMBER` |\n| AWS CodeBuild | `CODEBUILD_INITIATOR` |\n| Azure Pipelines | `BUILD_BUILDNUMBER` |\n| Bamboo | `bamboo_buildNumber` |\n| Bitbucket | `BITBUCKET_BUILD_NUMBER` |\n| Buildkite | `BUILDKITE_BUILD_ID` |\n| Circle | `CIRCLE_WORKFLOW_ID`, `CIRCLE_BUILD_NUM` |\n| Codeship | `CI_BUILD_NUMBER` |\n| Codeship Basic | `CI_BUILD_NUMBER` |\n| Codeship Pro | `CI_BUILD_ID` |\n| Drone | `DRONE_BUILD_NUMBER` |\n| GitLab | `CI_PIPELINE_ID` |\n| Jenkins | `BUILD_NUMBER` |\n| Semaphore | `SEMAPHORE_EXECUTABLE_UUID` |\n| Travis | `TRAVIS_BUILD_ID` |\n\nYou can pass a different value to link agents to the same run. For example, if you are using Jenkins and think the environment variable `BUILD_TAG` is more unique than the environment variable `BUILD_NUMBER`, pass the `BUILD_TAG` value via CLI [`--ci-build-id` flag](/llm/markdown/app/references/command-line.md#cypress-run-ci-build-id-lt-id-gt).\n\n```\ncypress run --record --parallel --ci-build-id $BUILD_TAG\n```\n",
      "section": "cloud",
      "anchors": [
        "linking-ci-machines-for-parallelization-or-grouping"
      ],
      "path": "/llm/json/chunked/cloud/features/smart-orchestration/parallelization.json",
      "token_estimate": 317
    },
    {
      "id": "cloud/features/smart-orchestration/parallelization#ci-build-id-environment-variables-by-provider",
      "doc_id": "cloud/features/smart-orchestration/parallelization",
      "heading": "CI Build ID environment variables by provider",
      "heading_level": 3,
      "content_markdown": "### CI Build ID environment variables by provider\n\nCypress currently uses the following CI environment variables to determine a CI build ID for a test run:\n\n| Provider | Environment Variable |\n| --- | --- |\n| AppVeyor | `APPVEYOR_BUILD_NUMBER` |\n| AWS CodeBuild | `CODEBUILD_INITIATOR` |\n| Azure Pipelines | `BUILD_BUILDNUMBER` |\n| Bamboo | `bamboo_buildNumber` |\n| Bitbucket | `BITBUCKET_BUILD_NUMBER` |\n| Buildkite | `BUILDKITE_BUILD_ID` |\n| Circle | `CIRCLE_WORKFLOW_ID`, `CIRCLE_BUILD_NUM` |\n| Codeship | `CI_BUILD_NUMBER` |\n| Codeship Basic | `CI_BUILD_NUMBER` |\n| Codeship Pro | `CI_BUILD_ID` |\n| Drone | `DRONE_BUILD_NUMBER` |\n| GitLab | `CI_PIPELINE_ID` |\n| Jenkins | `BUILD_NUMBER` |\n| Semaphore | `SEMAPHORE_EXECUTABLE_UUID` |\n| Travis | `TRAVIS_BUILD_ID` |\n\nYou can pass a different value to link agents to the same run. For example, if you are using Jenkins and think the environment variable `BUILD_TAG` is more unique than the environment variable `BUILD_NUMBER`, pass the `BUILD_TAG` value via CLI [`--ci-build-id` flag](/llm/markdown/app/references/command-line.md#cypress-run-ci-build-id-lt-id-gt).\n\n```\ncypress run --record --parallel --ci-build-id $BUILD_TAG\n```\n",
      "section": "cloud",
      "anchors": [
        "ci-build-id-environment-variables-by-provider"
      ],
      "path": "/llm/json/chunked/cloud/features/smart-orchestration/parallelization.json",
      "token_estimate": 223
    },
    {
      "id": "cloud/features/smart-orchestration/parallelization#run-completion-delay",
      "doc_id": "cloud/features/smart-orchestration/parallelization",
      "heading": "Run completion delay",
      "heading_level": 2,
      "content_markdown": "## Run completion delay\n\nDuring parallelization mode or when grouping runs, Cypress will wait for a specified amount of time before completing the test run in case any more relevant work remains. This is to compensate for various scenarios where CI machines could be backed-up in a queue.\n\nThis waiting period is called the **run completion delay** and it begins after the last known CI machine has completed as shown in the diagram below:\n\nThis **delay is 60 seconds by default**, but is [configurable within Cypress Cloud project settings page](/llm/markdown/cloud/account-management/projects.md#Run-completion-delay).\n",
      "section": "cloud",
      "anchors": [
        "run-completion-delay"
      ],
      "path": "/llm/json/chunked/cloud/features/smart-orchestration/parallelization.json",
      "token_estimate": 120
    },
    {
      "id": "cloud/features/smart-orchestration/parallelization#visualizing-parallelization-and-groups-in-cypress-cloud",
      "doc_id": "cloud/features/smart-orchestration/parallelization",
      "heading": "Visualizing parallelization and groups in Cypress Cloud",
      "heading_level": 2,
      "content_markdown": "## Visualizing parallelization and groups in Cypress Cloud\n\nYou can see the result of each spec file that ran within [Cypress Cloud](/llm/markdown/cloud/get-started/introduction.md) in the run's **Specs** tab. Specs are visualized within a **Timeline**, **Bar Chart**, and **Machines** view.\n\n### Timeline View\n\nThe Timeline View charts your spec files as they ran relative to each other. This is especially helpful when you want to visualize how your tests ran chronologically across all available machines.\n\n### Bar Chart View\n\nThe Bar Chart View visualizes the **duration** of your spec files relative to each other.\n\n### Machines View\n\nThe Machines View charts spec files by the machines that executed them. This view enables you to evaluate the contribution of each machine to the overall test run.\n",
      "section": "cloud",
      "anchors": [
        "visualizing-parallelization-and-groups-in-cypress-cloud"
      ],
      "path": "/llm/json/chunked/cloud/features/smart-orchestration/parallelization.json",
      "token_estimate": 164
    },
    {
      "id": "cloud/features/smart-orchestration/parallelization#timeline-view",
      "doc_id": "cloud/features/smart-orchestration/parallelization",
      "heading": "Timeline View",
      "heading_level": 3,
      "content_markdown": "### Timeline View\n\nThe Timeline View charts your spec files as they ran relative to each other. This is especially helpful when you want to visualize how your tests ran chronologically across all available machines.\n",
      "section": "cloud",
      "anchors": [
        "timeline-view"
      ],
      "path": "/llm/json/chunked/cloud/features/smart-orchestration/parallelization.json",
      "token_estimate": 47
    },
    {
      "id": "cloud/features/smart-orchestration/parallelization#machines-view",
      "doc_id": "cloud/features/smart-orchestration/parallelization",
      "heading": "Machines View",
      "heading_level": 3,
      "content_markdown": "### Machines View\n\nThe Machines View charts spec files by the machines that executed them. This view enables you to evaluate the contribution of each machine to the overall test run.\n",
      "section": "cloud",
      "anchors": [
        "machines-view"
      ],
      "path": "/llm/json/chunked/cloud/features/smart-orchestration/parallelization.json",
      "token_estimate": 41
    },
    {
      "id": "cloud/features/smart-orchestration/parallelization#next-steps",
      "doc_id": "cloud/features/smart-orchestration/parallelization",
      "heading": "Next Steps",
      "heading_level": 2,
      "content_markdown": "## Next Steps\n\n*   [Cypress Real World App](https://github.com/cypress-io/cypress-realworld-app) runs parallelized CI jobs across multiple operating systems, browsers, and viewport sizes.\n*   [Continuous Integration Guide](/llm/markdown/app/continuous-integration/overview.md)\n*   [Cross Browser Testing Guide](/llm/markdown/app/guides/cross-browser-testing.md)\n*   [Blog: Run Your End-to-end Tests 10 Times Faster with Automatic Test Parallelization](https://www.cypress.io/blog/2018/09/05/run-end-to-end-tests-on-ci-faster/)\n*   [CI Configurations in Kitchen Sink Example](https://github.com/cypress-io/cypress-example-kitchensink#ci-status)\n",
      "section": "cloud",
      "anchors": [
        "next-steps"
      ],
      "path": "/llm/json/chunked/cloud/features/smart-orchestration/parallelization.json",
      "token_estimate": 65
    }
  ]
}