diff --git a/buildscripts/resmokeconfig/suites/concurrency_replication.yml b/buildscripts/resmokeconfig/suites/concurrency_replication.yml
index cc15b15..c4f26f7 100644
--- a/buildscripts/resmokeconfig/suites/concurrency_replication.yml
+++ b/buildscripts/resmokeconfig/suites/concurrency_replication.yml
@@ -30,23 +30,37 @@ executor:
       - CheckReplDBHash
       - ValidateCollections
     tests: true
-  config: {}
+  config:
+    shell_options:
+      global_vars:
+        TestData:
+          disableImplicitSessions: true
   hooks:
   # The CheckReplDBHash hook waits until all operations have replicated to and have been applied
   # on the secondaries, so we run the ValidateCollections hook after it to ensure we're
   # validating the entire contents of the collection.
   #
   # TODO SERVER-26466: Add CheckReplOplogs hook to the concurrency suite.
-  - class: CheckReplDBHashInBackground
-  - class: ValidateCollectionsInBackground
-  - class: CheckReplDBHash
-  - class: ValidateCollections
-  - class: CleanupConcurrencyWorkloads
+  # - class: CheckReplDBHashInBackground
+  # - class: ValidateCollectionsInBackground
+  # - class: CheckReplDBHash
+  # - class: ValidateCollections
+  # - class: CleanupConcurrencyWorkloads
+  - class: SimulateCrashHook
   fixture:
     class: ReplicaSetFixture
     mongod_options:
       oplogSize: 1024
+      syncdelay: 20
+      wiredTigerCacheSizeGB: .30
+      wiredTigerEngineConfigString: timing_stress_for_test=[history_store_checkpoint_delay,checkpoint_slow]
       set_parameters:
+        TransactionRecordMinimumLifetimeMinutes: 1
+        localLogicalSessionTimeoutMinutes: 1
+        logicalSessionRefreshMillis: 10000
         enableTestCommands: 1
         roleGraphInvalidationIsFatal: 1
-    num_nodes: 3
+        minSnapshotHistoryWindowInSeconds: 0
+        wiredTigerEvictionDebugMode: true
+        disableLogicalSessionCacheRefresh: false
+    num_nodes: 2
diff --git a/buildscripts/resmokelib/core/process.py b/buildscripts/resmokelib/core/process.py
index 63e1857..dc0c956 100644
--- a/buildscripts/resmokelib/core/process.py
+++ b/buildscripts/resmokelib/core/process.py
@@ -20,6 +20,8 @@ from buildscripts.resmokelib import utils
 from buildscripts.resmokelib.core import pipe
 from buildscripts.resmokelib.testing.fixtures import interface as fixture_interface

+import signal
+
 # Attempt to avoid race conditions (e.g. hangs caused by a file descriptor being left open) when
 # starting subprocesses concurrently from multiple threads by guarding calls to subprocess.Popen()
 # with a lock. See https://bugs.python.org/issue2320 and https://bugs.python.org/issue12739 as
@@ -276,6 +278,12 @@ class Process(object):

         return " ".join(sb)

+    def pause(self):
+        self._process.send_signal(signal.SIGSTOP)
+
+    def resume(self):
+        self._process.send_signal(signal.SIGCONT)
+
     def __str__(self):
         if self.pid is None:
             return self.as_command()
diff --git a/buildscripts/resmokelib/testing/fixtures/standalone.py b/buildscripts/resmokelib/testing/fixtures/standalone.py
index d563a31..358caf8 100644
--- a/buildscripts/resmokelib/testing/fixtures/standalone.py
+++ b/buildscripts/resmokelib/testing/fixtures/standalone.py
@@ -179,8 +179,8 @@ class MongoDFixture(interface.Fixture):
 # The default verbosity setting for any tests that are not started with an Evergreen task id. This
 # will apply to any tests run locally.
 DEFAULT_MONGOD_LOG_COMPONENT_VERBOSITY = {
-    "replication": {"rollback": 2}, "sharding": {"migration": 2}, "transaction": 4,
-    "tenantMigration": 4
+#    "replication": {"rollback": 2}, "sharding": {"migration": 2}, "transaction": 4,
+#    "tenantMigration": 4
 }

 # The default verbosity setting for any mongod processes running in Evergreen i.e. started with an
@@ -250,10 +250,10 @@ class MongodLauncher(object):
         # Set coordinateCommitReturnImmediatelyAfterPersistingDecision to false so that tests do
         # not need to rely on causal consistency or explicitly wait for the transaction to finish
         # committing.
-        if "coordinateCommitReturnImmediatelyAfterPersistingDecision" not in suite_set_parameters:
-            suite_set_parameters["coordinateCommitReturnImmediatelyAfterPersistingDecision"] = False
+        # if "coordinateCommitReturnImmediatelyAfterPersistingDecision" not in suite_set_parameters:
+        #     suite_set_parameters["coordinateCommitReturnImmediatelyAfterPersistingDecision"] = False

-        suite_set_parameters["reshardingMinimumOperationDurationMillis"] = 5000
+        #suite_set_parameters["reshardingMinimumOperationDurationMillis"] = 5000

         # There's a periodic background thread that checks for and aborts expired transactions.
         # "transactionLifetimeLimitSeconds" specifies for how long a transaction can run before expiring
@@ -280,9 +280,10 @@ class MongodLauncher(object):
         # The default time for stepdown and quiesce mode in response to SIGTERM is 15 seconds. Reduce
         # this to 100ms for faster shutdown. On branches 4.4 and earlier, there is no quiesce mode, but
         # the default time for stepdown is 10 seconds.
-        if ("replSet" in mongod_options
-                and "shutdownTimeoutMillisForSignaledShutdown" not in suite_set_parameters):
-            suite_set_parameters["shutdownTimeoutMillisForSignaledShutdown"] = 100
+
+        # if ("replSet" in mongod_options
+        #         and "shutdownTimeoutMillisForSignaledShutdown" not in suite_set_parameters):
+        #     suite_set_parameters["shutdownTimeoutMillisForSignaledShutdown"] = 100

         if "enableFlowControl" not in suite_set_parameters and self.config.FLOW_CONTROL is not None:
             suite_set_parameters["enableFlowControl"] = (self.config.FLOW_CONTROL == "on")
diff --git a/buildscripts/resmokelib/testing/hooks/interface.py b/buildscripts/resmokelib/testing/hooks/interface.py
index feafc9d..f8d2680 100644
--- a/buildscripts/resmokelib/testing/hooks/interface.py
+++ b/buildscripts/resmokelib/testing/hooks/interface.py
@@ -38,6 +38,9 @@ class Hook(object, metaclass=registry.make_registry_metaclass(_HOOKS)):  # pylin
             raise ValueError(
                 "Concrete Hook subclasses must override the IS_BACKGROUND class property")

+    def has_failed(self):
+        return False
+
     def before_suite(self, test_report):
         """Test runner calls this exactly once before they start running the suite."""
         pass
diff --git a/buildscripts/resmokelib/testing/hooks/simulate_crash.py b/buildscripts/resmokelib/testing/hooks/simulate_crash.py
new file mode 100644
index 0000000..013a446
--- /dev/null
+++ b/buildscripts/resmokelib/testing/hooks/simulate_crash.py
@@ -0,0 +1,151 @@
+import os
+import pprint
+import pymongo
+import random
+import shutil
+import sys
+import threading
+import time
+
+from buildscripts.resmokelib.core import process
+from buildscripts.resmokelib.testing.hooks import interface
+
+def validate(mdb, logger, orig_port):
+    """Return true on a successful validate."""
+    for db in mdb.database_names():
+        for coll in mdb.get_database(db).list_collection_names():
+            resp = mdb.get_database(db).command({"validate": coll}, check=False)
+            if "fsmdb" in db or coll == "transactions":
+                logger.info("DBG. Port: {} Resp: {}".format(orig_port, resp))
+            if resp['ok'] != 1.0 or resp['valid'] != True:
+                if 'code' in resp and resp['code'] == 166:
+                    pass
+                else:
+                    logger.info("DBG. FAILURE!\nCmdLineOpts: {}\nValidate Response: {}",
+                                pprint.pformat(mdb.admin.command("getCmdLineOpts")),
+                                pprint.pformat(resp))
+                    return False
+
+    return True
+
+class BGJob(threading.Thread):
+    def __init__(self, hook):
+        threading.Thread.__init__(self, name="SimulateCrashes")
+        self.daemon = True
+        self._hook = hook
+        self._lock = threading.Lock()
+        self._is_alive = True
+        self.backup_num = 0
+        self.found_error = False
+
+    def run(self):
+        while True:
+            with self._lock:
+                if self.is_alive == False:
+                    break
+
+            self._hook.pause_and_copy(self.backup_num)
+            if not self._hook.validate_all(self.backup_num):
+                self.found_error = True
+                self._hook.running_test.fixture.teardown()
+                self.is_alive = False
+                return
+
+            time.sleep(random.randint(1, 5))
+            self.backup_num += 1
+
+    def kill(self):
+        with self._lock:
+            self.is_alive = False
+
+class SimulateCrashHook(interface.Hook):
+    IS_BACKGROUND = True
+
+    def __init__(self, hook_logger, fixture):
+        interface.Hook.__init__(self, hook_logger, fixture, "Simulate crashes by sigstopping and copying the datafiles with DirectI/O")
+        self.logger = hook_logger
+        self.last_validate_port = 19000
+
+    def has_failed(self):
+        return self.found_error
+
+    def before_suite(self, test_report):
+        """Test runner calls this exactly once before they start running the suite."""
+        shutil.rmtree('./tmp', ignore_errors=True)
+
+        self.logger.info("DBG. Starting the SimulateCrashes thread.")
+        self._background_job = BGJob(self)
+        self._background_job.start()
+
+    def pause_and_copy(self, backup_num):
+        self.logger.info("DBG. Taking snapshot #{}".format(backup_num))
+        cpy = [x for x in self.fixture.nodes]
+        random.shuffle(cpy)
+
+        for node in cpy:
+            node.mongod.pause()
+
+            try:
+                for tup in os.walk(node._dbpath, followlinks=True):
+                    if tup[0].endswith('/diagnostic.data') or tup[0].endswith('/_tmp'):
+                        continue
+                    for filename in tup[-1]:
+                        if 'Preplog' in filename:
+                            continue
+                        fqfn = '/'.join([tup[0], filename])
+                        self.copy_file(node._dbpath, fqfn, './tmp/d{}/{}'.format(node.port, backup_num))
+            finally:
+                node.mongod.resume()
+
+
+    def copy_file(self, root, fqfn, new_root):
+        # in_fd = os.open(fqfn, os.O_RDONLY | os.O_DIRECT)
+        in_fd = os.open(fqfn, os.O_RDONLY)
+        in_bytes = os.stat(in_fd).st_size
+
+        rel = fqfn[len(root):]
+        os.makedirs(new_root + '/journal', exist_ok=True)
+        out_fd = os.open(new_root + rel, os.O_WRONLY | os.O_CREAT)
+        os.sendfile(out_fd, in_fd, 0, in_bytes)
+        os.close(out_fd)
+        os.close(in_fd)
+
+    def validate_all(self, backup_num):
+        for node in self.fixture.nodes:
+            if self.last_validate_port >= 20000:
+                self.last_validate_port = 19000
+            validate_port = self.last_validate_port
+            self.last_validate_port += 1
+
+            path = "tmp/d{}/{}".format(node.port, backup_num)
+            self.logger.info("DBG. Starting to validate. DBPath: {} Port: {}".format(path, validate_port))
+            mdb = process.Process(self.logger,
+                                  ['./mongod',
+                                   '--dbpath', path,
+                                   '--port', str(validate_port),
+                                   '--logpath', 'tmp/validate.log'])
+            mdb.start()
+            client = pymongo.MongoClient('localhost:{}'.format(validate_port))
+            is_valid = validate(client, self.logger, node.port)
+            mdb.stop()
+            if not is_valid:
+                return False
+            shutil.rmtree(path, ignore_errors=True)
+            return True
+
+    def after_suite(self, test_report):
+        """Invoke by test runner calls this exactly once after all tests have finished executing.
+
+        Be sure to reset the behavior back to its original state so that it can be run again.
+        """
+        self._background_job.kill()
+
+        self._background_job.join()
+
+    def before_test(self, test, test_report):
+        """Each test will call this before it executes."""
+        self.running_test = test
+
+    def after_test(self, test, test_report):
+        """Each test will call this after it executes."""
+        pass
diff --git a/jstests/concurrency/fsm_workloads/write_heavy.js b/jstests/concurrency/fsm_workloads/write_heavy.js
new file mode 100644
index 0000000..a7c3cc3
--- /dev/null
+++ b/jstests/concurrency/fsm_workloads/write_heavy.js
@@ -0,0 +1,64 @@
+'use strict';
+
+var $config = (function() {
+    const collSize = 10 * 1024 * 1024;
+    const docSize = 8000;
+    const numDocs = collSize / docSize;
+
+    const states = {
+        update: function update(db, collName) {
+            let docId = Random.randInt(numDocs);
+            assert.commandWorked(this.coll.update(
+                {docNum: docId}, {$set: {time: ObjectId().getTimestamp()}, $inc: {numUpdates: 1}}));
+        },
+
+        changeSession: function changeSession(db, collName) {
+            this.coll = db.getMongo()
+                            .startSession({retryWrites: true})
+                            .getDatabase(db.getName())
+                            .getCollection(collName);
+        },
+    };
+
+    function setup(db, collName, cluster) {
+        let population = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+        const coll = db.getCollection(collName);
+        let val = [];
+        jsTestLog({"DBG. Populating. NumDocs": numDocs});
+        for (var stringNum = 0; stringNum < 8; ++stringNum) {
+            let str = "";
+            for (var stringLen = 0; stringLen < 1000; ++stringLen) {
+                str += population[Random.randInt(population.length)];
+            }
+            val.push(str);
+        }
+
+        let bulk = coll.initializeUnorderedBulkOp();
+        for (var docNum = 0; docNum < numDocs; ++docNum) {
+            bulk.insert({time: ObjectId().getTimestamp(), val: val, docNum: docNum});
+        }
+        assert.commandWorked(bulk.execute());
+
+        db.getCollection(collName).createIndexes([{docNum: 1}, {time: 1}, {numUpdates: 1}]);
+    }
+
+    function teardown(db, collName, cluster) {
+        jsTestLog({"DBG. Validate": db.getCollection(collName).validate()});
+        jsTestLog({"DBG. Stats": db.getCollection(collName).stats()});
+    }
+
+    const transitions = {
+        update: {update: 1},
+        changeSession: {update: 1},
+    };
+
+    return {
+        threadCount: 10,
+        iterations: 10090,
+        startState: 'changeSession',
+        states: states,
+        transitions: transitions,
+        setup: setup,
+        teardown: teardown,
+    };
+})();
