diff --git a/doc/api/cli.md b/doc/api/cli.md
index 46007c5b86b927..59318c7d9302c0 100644
--- a/doc/api/cli.md
+++ b/doc/api/cli.md
@@ -2254,6 +2254,17 @@ Starts the Node.js command line test runner. This flag cannot be combined with
 See the documentation on [running tests from the command line][]
 for more details.
 
+### `--test-bail`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+> Stability: 1 - Experimental
+
+Instructs the test runner to bail out if a test failure occurs.
+See the documentation on [test bailout][] for more details.
+
 ### `--test-concurrency`
 
 <!-- YAML
@@ -3714,6 +3725,7 @@ node --stack-trace-limit=12 -p -e "Error.stackTraceLimit" # prints 12
 [single executable application]: single-executable-applications.md
 [snapshot testing]: test.md#snapshot-testing
 [syntax detection]: packages.md#syntax-detection
+[test bailout]: test.md#bailing-out
 [test reporters]: test.md#test-reporters
 [test runner execution model]: test.md#test-runner-execution-model
 [timezone IDs]: https://en.wikipedia.org/wiki/List_of_tz_database_time_zones
diff --git a/doc/api/test.md b/doc/api/test.md
index 92276017fd63d0..f2a27f8f79c6be 100644
--- a/doc/api/test.md
+++ b/doc/api/test.md
@@ -990,6 +990,23 @@ exports[`suite of snapshot tests > snapshot test 2`] = `
 Once the snapshot file is created, run the tests again without the
 `--test-update-snapshots` flag. The tests should pass now.
 
+## Bailing out
+
+<!-- YAML
+added:
+  - REPLACEME
+-->
+
+> Stability: 1 - Experimental
+
+The `--test-bail` flag provides a way to stop test execution
+as soon as a test fails.
+By enabling this flag, the test runner will exit the test suite early
+when it encounters the first failing test, preventing
+the execution of subsequent tests.
+Already running tests will be canceled, and no further tests will be started.
+**Default:** `false`.
+
 ## Test reporters
 
 <!-- YAML
@@ -1077,6 +1094,9 @@ const customReporter = new Transform({
       case 'test:fail':
         callback(null, `test ${event.data.name} failed`);
         break;
+      case 'test:bail':
+        callback(null, `test ${event.data.name} bailed out`);
+        break;
       case 'test:plan':
         callback(null, 'test plan');
         break;
@@ -1122,6 +1142,9 @@ const customReporter = new Transform({
       case 'test:fail':
         callback(null, `test ${event.data.name} failed`);
         break;
+      case 'test:bail':
+        callback(null, `test ${event.data.name} bailed out`);
+        break;
       case 'test:plan':
         callback(null, 'test plan');
         break;
@@ -1166,6 +1189,9 @@ export default async function * customReporter(source) {
       case 'test:fail':
         yield `test ${event.data.name} failed\n`;
         break;
+      case 'test:bail':
+        yield `test ${event.data.name} bailed out\n`;
+        break;
       case 'test:plan':
         yield 'test plan\n';
         break;
@@ -1206,6 +1232,9 @@ module.exports = async function * customReporter(source) {
       case 'test:fail':
         yield `test ${event.data.name} failed\n`;
         break;
+      case 'test:bail':
+        yield `test ${event.data.name} bailed out\n`;
+        break;
       case 'test:plan':
         yield 'test plan\n';
         break;
@@ -1483,6 +1512,11 @@ changes:
   does not have a name.
 * `options` {Object} Configuration options for the test. The following
   properties are supported:
+  * `bail` {boolean}
+    If `true`, it will exit the test suite early
+    when it encounters the first failing test, preventing
+    the execution of subsequent tests and canceling already running tests.
+    **Default:** `false`.
   * `concurrency` {number|boolean} If a number is provided,
     then that many tests would run in parallel within the application thread.
     If `true`, all scheduled asynchronous tests run concurrently within the
@@ -3124,6 +3158,22 @@ generated for each test file in addition to a final cumulative summary.
 
 Emitted when no more tests are queued for execution in watch mode.
 
+### Event: `'test:bail'`
+
+* `data` {Object}
+  * `column` {number|undefined} The column number where the test is defined, or
+    `undefined` if the test was run through the REPL.
+  * `file` {string|undefined} The path of the test file,
+    `undefined` if test was run through the REPL.
+  * `line` {number|undefined} The line number where the test is defined, or
+    `undefined` if the test was run through the REPL.
+  * `name` {string} The test name.
+  * `nesting` {number} The nesting level of the test.
+
+Emitted when the test runner stops executing tests due to the [`--test-bail`][] flag.
+This event signals that the first failing test caused the suite to bail out,
+canceling all pending and currently running tests.
+
 ## Class: `TestContext`
 
 <!-- YAML
@@ -3618,6 +3668,7 @@ Can be used to abort test subtasks when the test has been aborted.
 [`--experimental-test-module-mocks`]: cli.md#--experimental-test-module-mocks
 [`--import`]: cli.md#--importmodule
 [`--no-experimental-strip-types`]: cli.md#--no-experimental-strip-types
+[`--test-bail`]: cli.md#--test-bail
 [`--test-concurrency`]: cli.md#--test-concurrency
 [`--test-coverage-exclude`]: cli.md#--test-coverage-exclude
 [`--test-coverage-include`]: cli.md#--test-coverage-include
diff --git a/lib/internal/test_runner/harness.js b/lib/internal/test_runner/harness.js
index e9356cbc0100bb..7a4ae8bd007257 100644
--- a/lib/internal/test_runner/harness.js
+++ b/lib/internal/test_runner/harness.js
@@ -76,6 +76,7 @@ function createTestTree(rootTestOptions, globalOptions) {
 
       buildPhaseDeferred.resolve();
     },
+    testsProcesses: new SafeMap(),
   };
 
   harness.resetCounters();
diff --git a/lib/internal/test_runner/reporter/spec.js b/lib/internal/test_runner/reporter/spec.js
index 2092d22e3fe77f..e5a2cda86e1225 100644
--- a/lib/internal/test_runner/reporter/spec.js
+++ b/lib/internal/test_runner/reporter/spec.js
@@ -9,7 +9,7 @@ const {
 const assert = require('assert');
 const Transform = require('internal/streams/transform');
 const colors = require('internal/util/colors');
-const { kSubtestsFailed } = require('internal/test_runner/test');
+const { kSubtestsFailed, kTestBailedOut } = require('internal/test_runner/test');
 const { getCoverageReport } = require('internal/test_runner/utils');
 const { relative } = require('path');
 const {
@@ -57,6 +57,7 @@ class SpecReporter extends Transform {
   #handleEvent({ type, data }) {
     switch (type) {
       case 'test:fail':
+        if (data.details?.error?.failureType === kTestBailedOut) break;
         if (data.details?.error?.failureType !== kSubtestsFailed) {
           ArrayPrototypePush(this.#failedTests, data);
         }
@@ -74,6 +75,8 @@ class SpecReporter extends Transform {
       case 'test:coverage':
         return getCoverageReport(indent(data.nesting), data.summary,
                                  reporterUnicodeSymbolMap['test:coverage'], colors.blue, true);
+      case 'test:bail':
+        return `${reporterColorMap[type]}${reporterUnicodeSymbolMap[type]}Bail out!${colors.white}\n`;
     }
   }
   _transform({ type, data }, encoding, callback) {
diff --git a/lib/internal/test_runner/reporter/tap.js b/lib/internal/test_runner/reporter/tap.js
index 0f2aa6a722f858..185eb5e5619762 100644
--- a/lib/internal/test_runner/reporter/tap.js
+++ b/lib/internal/test_runner/reporter/tap.js
@@ -33,6 +33,7 @@ async function * tapReporter(source) {
   for await (const { type, data } of source) {
     switch (type) {
       case 'test:fail': {
+        if (data.details?.error?.failureType === lazyLoadTest().kTestBailedOut) break;
         yield reportTest(data.nesting, data.testNumber, 'not ok', data.name, data.skip, data.todo);
         const location = data.file ? `${data.file}:${data.line}:${data.column}` : null;
         yield reportDetails(data.nesting, data.details, location);
@@ -61,6 +62,9 @@ async function * tapReporter(source) {
       case 'test:coverage':
         yield getCoverageReport(indent(data.nesting), data.summary, '# ', '', true);
         break;
+      case 'test:bail':
+        yield `${indent(data.nesting)}Bail out!\n`;
+        break;
     }
   }
 }
diff --git a/lib/internal/test_runner/reporter/utils.js b/lib/internal/test_runner/reporter/utils.js
index 9b6cc96a185a9a..b76cc55adce78e 100644
--- a/lib/internal/test_runner/reporter/utils.js
+++ b/lib/internal/test_runner/reporter/utils.js
@@ -24,6 +24,7 @@ const reporterUnicodeSymbolMap = {
   'test:coverage': '\u2139 ',
   'arrow:right': '\u25B6 ',
   'hyphen:minus': '\uFE63 ',
+  'test:bail': '\u2716 ',
 };
 
 const reporterColorMap = {
@@ -37,6 +38,9 @@ const reporterColorMap = {
   get 'test:diagnostic'() {
     return colors.blue;
   },
+  get 'test:bail'() {
+    return colors.red;
+  },
 };
 
 function indent(nesting) {
diff --git a/lib/internal/test_runner/runner.js b/lib/internal/test_runner/runner.js
index 43a62b5b4307e4..dfcd0ebc461e2d 100644
--- a/lib/internal/test_runner/runner.js
+++ b/lib/internal/test_runner/runner.js
@@ -76,6 +76,7 @@ const {
   kSubtestsFailed,
   kTestCodeFailure,
   kTestTimeoutFailure,
+  kTestBailedOut,
   Test,
 } = require('internal/test_runner/test');
 
@@ -101,7 +102,10 @@ const kFilterArgValues = ['--test-reporter', '--test-reporter-destination'];
 const kDiagnosticsFilterArgs = ['tests', 'suites', 'pass', 'fail', 'cancelled', 'skipped', 'todo', 'duration_ms'];
 
 const kCanceledTests = new SafeSet()
-  .add(kCancelledByParent).add(kAborted).add(kTestTimeoutFailure);
+  .add(kCancelledByParent)
+  .add(kAborted)
+  .add(kTestTimeoutFailure)
+  .add(kTestBailedOut);
 
 let kResistStopPropagation;
 
@@ -137,7 +141,8 @@ function getRunArgs(path, { forceExit,
                             only,
                             argv: suppliedArgs,
                             execArgv,
-                            cwd }) {
+                            cwd,
+                            bail }) {
   const argv = ArrayPrototypeFilter(process.execArgv, filterExecArgv);
   if (forceExit === true) {
     ArrayPrototypePush(argv, '--test-force-exit');
@@ -154,6 +159,9 @@ function getRunArgs(path, { forceExit,
   if (only === true) {
     ArrayPrototypePush(argv, '--test-only');
   }
+  if (bail === true) {
+    ArrayPrototypePush(argv, '--test-bail');
+  }
 
   ArrayPrototypePushApply(argv, execArgv);
 
@@ -216,6 +224,14 @@ class FileTest extends Test {
     if (item.data.details?.error) {
       item.data.details.error = deserializeError(item.data.details.error);
     }
+    if (item.type === 'test:bail') {
+      // <-- here we need to stop all the pending test files (aka subprocesses)
+      // To be replaced, just for poc
+      this.root.harness.testsProcesses.forEach((child) => {
+        child.kill();
+      });
+      return;
+    }
     if (item.type === 'test:pass' || item.type === 'test:fail') {
       item.data.testNumber = isTopLevel ? (this.root.harness.counters.topLevel + 1) : item.data.testNumber;
       countCompletedTest({
@@ -362,7 +378,12 @@ function runTestFile(path, filesWatcher, opts) {
   const watchMode = filesWatcher != null;
   const testPath = path === kIsolatedProcessName ? '' : path;
   const testOpts = { __proto__: null, signal: opts.signal };
+  const subtestProcesses = opts.root.harness.testsProcesses;
   const subtest = opts.root.createSubtest(FileTest, testPath, testOpts, async (t) => {
+    if (opts.root.bailed) {
+      // TODO(pmarchini): this is a temporary solution to avoid running tests after bailing
+      return; // No-op in order to avoid running tests after bailing
+    }
     const args = getRunArgs(path, opts);
     const stdio = ['pipe', 'pipe', 'pipe'];
     const env = { __proto__: null, ...process.env, NODE_TEST_CONTEXT: 'child-v8' };
@@ -389,6 +410,7 @@ function runTestFile(path, filesWatcher, opts) {
       filesWatcher.runningProcesses.set(path, child);
       filesWatcher.watcher.watchChildProcessModules(child, path);
     }
+    subtestProcesses.set(path, child);
 
     let err;
 
@@ -422,6 +444,7 @@ function runTestFile(path, filesWatcher, opts) {
       finished(child.stdout, { __proto__: null, signal: t.signal }),
     ]);
 
+    subtestProcesses.delete(path);
     if (watchMode) {
       filesWatcher.runningProcesses.delete(path);
       filesWatcher.runningSubtests.delete(path);
@@ -478,6 +501,8 @@ function watchFiles(testFiles, opts) {
       // Reset the topLevel counter
       opts.root.harness.counters.topLevel = 0;
     }
+    // TODO(pmarchini): Reset the bailed flag to rerun the tests.
+    // This must be added only when we add support for bail in watch mode.
     await runningSubtests.get(file);
     runningSubtests.set(file, runTestFile(file, filesWatcher, opts));
   }
@@ -564,6 +589,7 @@ function run(options = kEmptyObject) {
     execArgv = [],
     argv = [],
     cwd = process.cwd(),
+    bail = false,
   } = options;
 
   if (files != null) {
@@ -663,6 +689,15 @@ function run(options = kEmptyObject) {
 
   validateStringArray(argv, 'options.argv');
   validateStringArray(execArgv, 'options.execArgv');
+  validateBoolean(bail, 'options.bail');
+  // TODO(pmarchini): watch mode with bail needs to be implemented
+  if (bail && watch) {
+    throw new ERR_INVALID_ARG_VALUE(
+      'options.bail',
+      watch,
+      'bail not supported while watch mode is enabled',
+    );
+  }
 
   const rootTestOptions = { __proto__: null, concurrency, timeout, signal };
   const globalOptions = {
@@ -678,6 +713,7 @@ function run(options = kEmptyObject) {
     branchCoverage: branchCoverage,
     functionCoverage: functionCoverage,
     cwd,
+    bail,
   };
   const root = createTestTree(rootTestOptions, globalOptions);
   let testFiles = files ?? createTestFileList(globPatterns, cwd);
@@ -705,6 +741,7 @@ function run(options = kEmptyObject) {
     isolation,
     argv,
     execArgv,
+    bail,
   };
 
   if (isolation === 'process') {
diff --git a/lib/internal/test_runner/test.js b/lib/internal/test_runner/test.js
index fdf875ceae81b7..9385f9f38568d1 100644
--- a/lib/internal/test_runner/test.js
+++ b/lib/internal/test_runner/test.js
@@ -76,6 +76,7 @@ const kSubtestsFailed = 'subtestsFailed';
 const kTestCodeFailure = 'testCodeFailure';
 const kTestTimeoutFailure = 'testTimeoutFailure';
 const kHookFailure = 'hookFailed';
+const kTestBailedOut = 'testBailedOut';
 const kDefaultTimeout = null;
 const noop = FunctionPrototype;
 const kShouldAbort = Symbol('kShouldAbort');
@@ -407,6 +408,7 @@ class Test extends AsyncResource {
       this.childNumber = 0;
       this.timeout = kDefaultTimeout;
       this.entryFile = entryFile;
+      this.bail = this.config.bail;
     } else {
       const nesting = parent.parent === null ? parent.nesting :
         parent.nesting + 1;
@@ -423,6 +425,7 @@ class Test extends AsyncResource {
       this.childNumber = parent.subtests.length + 1;
       this.timeout = parent.timeout;
       this.entryFile = parent.entryFile;
+      this.bail = parent.bail;
 
       if (isFilteringByName) {
         this.filteredByName = this.willBeFilteredByName();
@@ -506,6 +509,7 @@ class Test extends AsyncResource {
     this.cancelled = false;
     this.skipped = skip !== undefined && skip !== false;
     this.isTodo = todo !== undefined && todo !== false;
+    this.bailed = false;
     this.startTime = null;
     this.endTime = null;
     this.passed = false;
@@ -705,12 +709,15 @@ class Test extends AsyncResource {
       return;
     }
 
-    this.fail(error ||
-      new ERR_TEST_FAILURE(
-        'test did not finish before its parent and was cancelled',
-        kCancelledByParent,
-      ),
+    const cancelledError = this.root.bailed ? new ERR_TEST_FAILURE(
+      'test bailed out',
+      kTestBailedOut,
+    ) : new ERR_TEST_FAILURE(
+      'test did not finish before its parent and was cancelled',
+      kCancelledByParent,
     );
+
+    this.fail(error || cancelledError);
     this.cancelled = true;
     this.abortController.abort();
   }
@@ -763,6 +770,13 @@ class Test extends AsyncResource {
 
     this.passed = false;
     this.error = err;
+
+    if (this.bail && !this.root.bailed) {
+      this.root.bailed = true;
+      this.bailed = true;
+      this.endTime ??= hrtime();
+      this.root.postRun();
+    }
   }
 
   pass() {
@@ -1034,6 +1048,11 @@ class Test extends AsyncResource {
         reporter,
       } = this;
 
+      // We're reporting the bail into the testStream in order to allow the runner to interrupt the active processes
+      if (this.bailed) {
+        reporter.bail(this.nesting, this.loc, this.name);
+      }
+
       this.reported = true;
       reporter.plan(nesting, loc, harness.counters.topLevel);
 
@@ -1329,6 +1348,7 @@ module.exports = {
   kTestTimeoutFailure,
   kAborted,
   kUnwrapErrors,
+  kTestBailedOut,
   Suite,
   Test,
 };
diff --git a/lib/internal/test_runner/tests_stream.js b/lib/internal/test_runner/tests_stream.js
index 2fda1e68069c19..db7b28595645ff 100644
--- a/lib/internal/test_runner/tests_stream.js
+++ b/lib/internal/test_runner/tests_stream.js
@@ -46,6 +46,15 @@ class TestsStream extends Readable {
     });
   }
 
+  bail(nesting, loc, name) {
+    this[kEmitMessage]('test:bail', {
+      __proto__: null,
+      nesting,
+      name,
+      ...loc,
+    });
+  }
+
   ok(nesting, loc, testNumber, name, details, directive) {
     this[kEmitMessage]('test:pass', {
       __proto__: null,
diff --git a/lib/internal/test_runner/utils.js b/lib/internal/test_runner/utils.js
index 8e0a920ea7756f..2ff7ad6a7cc3ab 100644
--- a/lib/internal/test_runner/utils.js
+++ b/lib/internal/test_runner/utils.js
@@ -198,6 +198,7 @@ function parseCommandLine() {
   const watch = getOptionValue('--watch');
   const isChildProcess = process.env.NODE_TEST_CONTEXT === 'child';
   const isChildProcessV8 = process.env.NODE_TEST_CONTEXT === 'child-v8';
+  const bail = getOptionValue('--test-bail');
   let concurrency;
   let coverageExcludeGlobs;
   let coverageIncludeGlobs;
@@ -337,6 +338,7 @@ function parseCommandLine() {
     timeout,
     updateSnapshots,
     watch,
+    bail,
   };
 
   return globalTestOptions;
diff --git a/src/node_options.cc b/src/node_options.cc
index 8d529651342ba6..caee14e250def6 100644
--- a/src/node_options.cc
+++ b/src/node_options.cc
@@ -1,4 +1,5 @@
 #include "node_options.h"  // NOLINT(build/include_inline)
+#include "node.h"
 #include "node_options-inl.h"
 
 #include "env-inl.h"
@@ -738,6 +739,10 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() {
             "exclude files from coverage report that match this glob pattern",
             &EnvironmentOptions::coverage_exclude_pattern,
             kAllowedInEnvvar);
+  AddOption("--test-bail",
+            "stop test runner execution on the first test failure",
+            &EnvironmentOptions::test_bail,
+            kDisallowedInEnvvar);
   AddOption("--test-udp-no-try-send", "",  // For testing only.
             &EnvironmentOptions::test_udp_no_try_send);
   AddOption("--throw-deprecation",
diff --git a/src/node_options.h b/src/node_options.h
index 9563f90f41f7d8..50b228763a42fc 100644
--- a/src/node_options.h
+++ b/src/node_options.h
@@ -201,6 +201,7 @@ class EnvironmentOptions : public Options {
   std::vector<std::string> test_skip_pattern;
   std::vector<std::string> coverage_include_pattern;
   std::vector<std::string> coverage_exclude_pattern;
+  bool test_bail = false;
   bool throw_deprecation = false;
   bool trace_deprecation = false;
   bool trace_exit = false;
diff --git a/test/fixtures/test-runner/bailout/sequential.test.mjs b/test/fixtures/test-runner/bailout/sequential.test.mjs
new file mode 100644
index 00000000000000..cc58d9bbf6b2c3
--- /dev/null
+++ b/test/fixtures/test-runner/bailout/sequential.test.mjs
@@ -0,0 +1,12 @@
+
+import { describe, it } from "node:test";
+
+describe("sequential", {concurrency: false }, () => {
+  it("first", async () => {
+    throw new Error("First test failed");
+  });
+
+  it("second", () => {
+    throw new Error("Second test should not run");
+  });
+})
diff --git a/test/fixtures/test-runner/bailout/suite.test.mjs b/test/fixtures/test-runner/bailout/suite.test.mjs
new file mode 100644
index 00000000000000..a9f4a3b9692f7d
--- /dev/null
+++ b/test/fixtures/test-runner/bailout/suite.test.mjs
@@ -0,0 +1,11 @@
+import { describe, it } from "node:test";
+
+describe("sequential", async () => {
+  it("first", async () => {
+    await new Promise(resolve => setTimeout(resolve, 2000));
+  });
+
+  it("second", () => {
+    throw new Error("Second test should not run");
+  });
+})
diff --git a/test/fixtures/test-runner/output/bail-spec.js b/test/fixtures/test-runner/output/bail-spec.js
new file mode 100644
index 00000000000000..e9ff29b7015b90
--- /dev/null
+++ b/test/fixtures/test-runner/output/bail-spec.js
@@ -0,0 +1,18 @@
+'use strict';
+const common = require('../../../common');
+const test = require('node:test');
+
+test('nested', (t) => {
+  t.test('first', () => {});
+  t.test('second', () => {
+    throw new Error();
+  });
+  t.test('third', common.mustNotCall(() => {}));
+});
+
+test('top level', (t) => {
+  t.test('fourth', () => {});
+  t.test('fifth', () => {
+    throw new Error();
+  });
+});
diff --git a/test/fixtures/test-runner/output/bail-spec.snapshot b/test/fixtures/test-runner/output/bail-spec.snapshot
new file mode 100644
index 00000000000000..03412754dc7900
--- /dev/null
+++ b/test/fixtures/test-runner/output/bail-spec.snapshot
@@ -0,0 +1,32 @@
+▶ nested
+  ✔ first (*ms)
+  ✖ second (*ms)
+    Error
+        *
+        *
+        *
+        *
+        *
+        *
+
+✖ Bail out!
+ℹ tests 5
+ℹ suites 0
+ℹ pass 1
+ℹ fail 1
+ℹ cancelled 3
+ℹ skipped 0
+ℹ todo 0
+ℹ duration_ms *
+
+✖ failing tests:
+
+*
+✖ second (*ms)
+  Error
+      *
+      *
+      *
+      *
+      *
+      *
diff --git a/test/fixtures/test-runner/output/bail-tap.js b/test/fixtures/test-runner/output/bail-tap.js
new file mode 100644
index 00000000000000..e9ff29b7015b90
--- /dev/null
+++ b/test/fixtures/test-runner/output/bail-tap.js
@@ -0,0 +1,18 @@
+'use strict';
+const common = require('../../../common');
+const test = require('node:test');
+
+test('nested', (t) => {
+  t.test('first', () => {});
+  t.test('second', () => {
+    throw new Error();
+  });
+  t.test('third', common.mustNotCall(() => {}));
+});
+
+test('top level', (t) => {
+  t.test('fourth', () => {});
+  t.test('fifth', () => {
+    throw new Error();
+  });
+});
diff --git a/test/fixtures/test-runner/output/bail-tap.snapshot b/test/fixtures/test-runner/output/bail-tap.snapshot
new file mode 100644
index 00000000000000..34f5d1924b3c0d
--- /dev/null
+++ b/test/fixtures/test-runner/output/bail-tap.snapshot
@@ -0,0 +1,38 @@
+TAP version 13
+# Subtest: nested
+    # Subtest: first
+    ok 1 - first
+      ---
+      duration_ms: *
+      type: 'test'
+      ...
+    # Subtest: second
+    not ok 2 - second
+      ---
+      duration_ms: *
+      type: 'test'
+      location: '/test/fixtures/test-runner/output/bail-tap.js:(LINE):5'
+      failureType: 'testCodeFailure'
+      error: ''
+      code: 'ERR_TEST_FAILURE'
+      stack: |-
+        *
+        *
+        *
+        *
+        *
+        *
+      ...
+    # Subtest: third
+    1..3
+# Subtest: top level
+Bail out!
+1..2
+# tests 5
+# suites 0
+# pass 1
+# fail 1
+# cancelled 3
+# skipped 0
+# todo 0
+# duration_ms *
diff --git a/test/parallel/test-runner-bail.js b/test/parallel/test-runner-bail.js
new file mode 100644
index 00000000000000..abe4c7c3c36f2b
--- /dev/null
+++ b/test/parallel/test-runner-bail.js
@@ -0,0 +1,84 @@
+'use strict';
+
+require('../common');
+const fixtures = require('../common/fixtures');
+const { describe, it } = require('node:test');
+const { spawnSync } = require('node:child_process');
+const assert = require('node:assert');
+
+const bailTestFixtures = fixtures.path('test-runner/bailout');
+
+describe('node:test bail in watch mode', () => {
+
+  it('should not bail out if --test-bail is not set', () => {
+    const child = spawnSync(
+      process.execPath,
+      [
+        '--test',
+        '--test-reporter=spec',
+        '--test-concurrency=1',
+      ],
+      {
+        cwd: bailTestFixtures,
+      });
+
+    assert.strictEqual(child.stderr.toString(), '');
+
+    const output = child.stdout.toString();
+
+    assert.match(output, /tests 4/);
+    assert.match(output, /suites 2/);
+    assert.match(output, /pass 1/);
+    assert.match(output, /fail 3/);
+    assert.match(output, /cancelled 0/);
+  });
+
+  it('should bail out on the first failing test', () => {
+    const child = spawnSync(
+      process.execPath,
+      [
+        '--test',
+        '--test-bail',
+        '--test-reporter=spec',
+        '--test-concurrency=1',
+      ],
+      {
+        cwd: bailTestFixtures,
+      });
+
+    assert.strictEqual(child.stderr.toString(), '');
+
+    const output = child.stdout.toString();
+
+    assert.match(output, /tests 3/);
+    assert.match(output, /suites 1/);
+    assert.match(output, /pass 0/);
+    assert.match(output, /fail 1/);
+    assert.match(output, /cancelled 2/);
+  });
+
+  it('should bail out on the first failing test with isolation none', () => {
+    const child = spawnSync(
+      process.execPath,
+      [
+        '--test',
+        '--test-bail',
+        '--test-reporter=spec',
+        '--test-concurrency=1',
+        '--test-isolation=none',
+      ],
+      {
+        cwd: bailTestFixtures,
+      });
+
+    assert.strictEqual(child.stderr.toString(), '');
+
+    const output = child.stdout.toString();
+
+    assert.match(output, /tests 4/);
+    assert.match(output, /suites 2/);
+    assert.match(output, /pass 0/);
+    assert.match(output, /fail 1/);
+    assert.match(output, /cancelled 3/);
+  });
+});
diff --git a/test/parallel/test-runner-output.mjs b/test/parallel/test-runner-output.mjs
index 3bc4b0ad3d1a2e..3a46fae805dc39 100644
--- a/test/parallel/test-runner-output.mjs
+++ b/test/parallel/test-runner-output.mjs
@@ -295,6 +295,23 @@ const tests = [
     name: 'test-runner/output/coverage-width-infinity-uncovered-lines.mjs',
     flags: ['--test-reporter=tap', '--test-coverage-exclude=!test/**'],
   } : false,
+  {
+    name: 'test-runner/output/bail-spec.js',
+    flags: [
+      '--test',
+      '--test-bail',
+      '--test-reporter=spec',
+    ],
+    transform: specTransform,
+  },
+  {
+    name: 'test-runner/output/bail-tap.js',
+    flags: [
+      '--test',
+      '--test-bail',
+      '--test-reporter=tap',
+    ],
+  },
 ]
 .filter(Boolean)
 .map(({ flags, name, tty, transform }) => ({
diff --git a/test/parallel/test-runner-run.mjs b/test/parallel/test-runner-run.mjs
index 29b39049c1af0f..4cb3d11980f826 100644
--- a/test/parallel/test-runner-run.mjs
+++ b/test/parallel/test-runner-run.mjs
@@ -549,6 +549,19 @@ describe('require(\'node:test\').run', { concurrency: true }, () => {
       // eslint-disable-next-line no-unused-vars
       for await (const _ of stream);
     });
+
+    it('should only allow a boolean in options.bail', async () => {
+      [Symbol(), {}, [], () => { }, 0, 1, 0n, 1n, '', '1', Promise.resolve([])]
+        .forEach((bail) => assert.throws(() => run({ bail }), {
+          code: 'ERR_INVALID_ARG_TYPE'
+        }));
+    });
+
+    it('should not allow bail with watch mode', async () => {
+      assert.throws(() => run({ bail: true, watch: true }), {
+        code: 'ERR_INVALID_ARG_VALUE'
+      });
+    });
   });
 
   it('should avoid running recursively', async () => {
@@ -629,6 +642,93 @@ describe('require(\'node:test\').run', { concurrency: true }, () => {
       assert.strictEqual(diagnostics.includes(entry), true);
     }
   });
+
+  it('should handle the bail option', async () => {
+    const stream = run({
+      files: [join(testFixtures, 'bailout', 'sequential.test.mjs')],
+      bail: true
+    });
+
+    let failedTestCount = 0;
+    let passedTestCount = 0;
+    let bailedTestCount = 0;
+    for await (const data of stream) {
+      if (data.type === 'test:fail') {
+        failedTestCount++;
+      }
+      if (data.type === 'test:pass') {
+        passedTestCount++;
+      }
+      if (data.type === 'test:bail') {
+        bailedTestCount++;
+      }
+    }
+
+    assert.strictEqual(bailedTestCount, 1);
+    assert.strictEqual(failedTestCount, 3);
+    assert.strictEqual(passedTestCount, 0);
+  });
+
+  it('should handle the bail option with multiple files', async () => {
+    const stream = run({
+      files: [
+        join(testFixtures, 'bailout/sequential.test.mjs'),
+        join(testFixtures, 'bailout/suite.test.mjs'),
+      ],
+      bail: true,
+      concurrency: 2
+    });
+
+    let failedTestCount = 0;
+    let passedTestCount = 0;
+    let bailedTestCount = 0;
+    for await (const data of stream) {
+      if (data.type === 'test:fail') {
+        failedTestCount++;
+      }
+      if (data.type === 'test:pass') {
+        passedTestCount++;
+      }
+      if (data.type === 'test:bail') {
+        bailedTestCount++;
+      }
+    }
+
+    assert.strictEqual(bailedTestCount, 1);
+    assert.strictEqual(failedTestCount, 4);
+    assert.strictEqual(passedTestCount, 0);
+  });
+
+  it('should handle the bail option with isolation none', async () => {
+    const stream = run({
+      files: [join(testFixtures, 'bailout/sequential.test.mjs')],
+      bail: true,
+      isolation: 'none',
+    });
+
+    let failedTestCount = 0;
+    let passedTestCount = 0;
+    let bailedTestCount = 0;
+    for await (const data of stream) {
+      if (data.type === 'test:fail') {
+        failedTestCount++;
+      }
+      if (data.type === 'test:pass') {
+        passedTestCount++;
+      }
+      if (data.type === 'test:bail') {
+        bailedTestCount++;
+      }
+    }
+
+    assert.strictEqual(bailedTestCount, 1);
+    assert.strictEqual(failedTestCount, 3);
+    assert.strictEqual(passedTestCount, 0);
+  });
+
+  // TODO(pmarchini): Bailout is not supported in watch mode yet but it should be.
+  // We should enable this test once it is supported.
+  it.todo('should handle the bail option with watch mode');
 });
 
 describe('forceExit', () => {