diff --git a/.build/cassandra-deps-maven-pom.xml b/.build/cassandra-deps-maven-pom.xml
index c38a171fa2d9..5a1d2c58566f 100644
--- a/.build/cassandra-deps-maven-pom.xml
+++ b/.build/cassandra-deps-maven-pom.xml
@@ -161,6 +161,10 @@
       <groupId>com.github.jbellis</groupId>
       <artifactId>jamm</artifactId>
     </dependency>
+    <dependency>
+      <groupId>tools.profiler</groupId>
+      <artifactId>async-profiler</artifactId>
+    </dependency>
     <dependency>
       <groupId>io.netty</groupId>
       <artifactId>netty-all</artifactId>
diff --git a/.build/parent-maven-pom.xml b/.build/parent-maven-pom.xml
index dfad8661045a..8b834c4a876c 100644
--- a/.build/parent-maven-pom.xml
+++ b/.build/parent-maven-pom.xml
@@ -40,6 +40,7 @@
     <byteman.version>4.0.20</byteman.version>
     <netty.version>4.1.125.Final</netty.version>
     <ohc.version>0.5.1</ohc.version>
+    <async-profiler.version>4.2</async-profiler.version>
 
     <!-- These are referenced in build.xml, so need to be propagated from there -->
     <asm.version>@asm.version@</asm.version>
@@ -465,6 +466,11 @@
         <artifactId>jamm</artifactId>
         <version>${jamm.version}</version>
       </dependency>
+      <dependency>
+        <groupId>tools.profiler</groupId>
+        <artifactId>async-profiler</artifactId>
+        <version>${async-profiler.version}</version>
+      </dependency>
       <dependency>
         <!-- Test scoped jackson-dataformat-yaml also depends on snakeyaml. For now, these versions are aligned
         but if you happen to bump it here then exclude it in jackson-dataformat-yaml.
diff --git a/CHANGES.txt b/CHANGES.txt
index 06b33e984657..a18e86e2ea0d 100644
--- a/CHANGES.txt
+++ b/CHANGES.txt
@@ -1,4 +1,5 @@
 5.1
+ * Support low-overhead async profiling (CASSANDRA-20854)
  * Introducing comments and security labels for schema elements (CASSANDRA-20943)
  * Extend nodetool tablestats for dictionary memory usage (CASSANDRA-20940)
  * Introduce separate GCInspector thresholds for concurrent GC events (CASSANDRA-20980)
diff --git a/conf/jvm-server.options b/conf/jvm-server.options
index d850592db021..ebc79e9b9f24 100644
--- a/conf/jvm-server.options
+++ b/conf/jvm-server.options
@@ -156,6 +156,11 @@
 # Disable chronicle analytics. See CASSANDRA-19656
 -Dchronicle.analytics.disable=true
 
+# AsyncProfiler Flags
+#-Dcassandra.async_profiler.enabled=true|false
+#-Dcassandra.async_profiler.advanced_mode=true|false
+#-Dcassandra.async_profiler.output_directory=/tmp/cassandra-profiling
+
 ### Debug options
 
 # uncomment to enable flight recorder
diff --git a/src/java/org/apache/cassandra/config/CassandraRelevantProperties.java b/src/java/org/apache/cassandra/config/CassandraRelevantProperties.java
index 2bcf423c7ef3..15c7ce33ad7d 100644
--- a/src/java/org/apache/cassandra/config/CassandraRelevantProperties.java
+++ b/src/java/org/apache/cassandra/config/CassandraRelevantProperties.java
@@ -60,6 +60,9 @@ public enum CassandraRelevantProperties
     ALLOW_UNSAFE_REPLACE("cassandra.allow_unsafe_replace"),
     ALLOW_UNSAFE_TRANSIENT_CHANGES("cassandra.allow_unsafe_transient_changes"),
     APPROXIMATE_TIME_PRECISION_MS("cassandra.approximate_time_precision_ms", "2"),
+    ASYNC_PROFILER_ADVANCED_MODE("cassandra.async_profiler.advanced_mode", "false"),
+    ASYNC_PROFILER_ENABLED("cassandra.async_profiler.enabled", "true"),
+    ASYNC_PROFILER_OUTPUT_DIRECTORY("cassandra.async_profiler.output_directory", "/var/log/cassandra-profiling"),
     /** 2 ** GENSALT_LOG2_ROUNDS rounds of hashing will be performed. */
     AUTH_BCRYPT_GENSALT_LOG2_ROUNDS("cassandra.auth_bcrypt_gensalt_log2_rounds", "4"),
     /** We expect default values on cache retries and interval to be sufficient for everyone but have this escape hatch just in case. */
diff --git a/src/java/org/apache/cassandra/profiler/AsyncProfiler.java b/src/java/org/apache/cassandra/profiler/AsyncProfiler.java
new file mode 100644
index 000000000000..df126261541e
--- /dev/null
+++ b/src/java/org/apache/cassandra/profiler/AsyncProfiler.java
@@ -0,0 +1,46 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.cassandra.profiler;
+import org.apache.cassandra.tools.profiler.AsyncProfilerService;
+
+public abstract class AsyncProfiler implements AsyncProfilerMBean
+{
+    public static final String MBEAN_NAME = "org.apache.cassandra.profiler:type=AsyncProfiler";
+    private final AsyncProfilerService service = new AsyncProfilerService();
+
+    public void start(String event, String outputFormat, int timeout, String outputFileName)
+    {
+        getService().start(event, outputFormat, timeout, outputFileName);
+    }
+
+    public void stop(String outputFileName)
+    {
+        getService().stop(outputFileName);
+    }
+
+    public boolean isAvailable()
+    {
+        return getService().isAvailable();
+    }
+
+    public AsyncProfilerService getService()
+    {
+        return service;
+    }
+}
diff --git a/src/java/org/apache/cassandra/profiler/AsyncProfilerMBean.java b/src/java/org/apache/cassandra/profiler/AsyncProfilerMBean.java
new file mode 100644
index 000000000000..fdeceef45c9f
--- /dev/null
+++ b/src/java/org/apache/cassandra/profiler/AsyncProfilerMBean.java
@@ -0,0 +1,30 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.cassandra.profiler;
+
+public interface AsyncProfilerMBean
+{
+    void start(String event, String outputFormat, int timeout, String outputFileName);
+
+    void stop(String outputFileName);
+
+    void execute(String command);
+
+    boolean isAvailable();
+}
diff --git a/src/java/org/apache/cassandra/profiler/AsyncProfilerSafe.java b/src/java/org/apache/cassandra/profiler/AsyncProfilerSafe.java
new file mode 100644
index 000000000000..8301e01ff381
--- /dev/null
+++ b/src/java/org/apache/cassandra/profiler/AsyncProfilerSafe.java
@@ -0,0 +1,29 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.cassandra.profiler;
+
+public class AsyncProfilerSafe extends AsyncProfiler
+{
+    public void execute(String command)
+    {
+        throw new SecurityException(String.format("Execute commands are not permitted " +
+                                                  "with this MBean. Please use unsafe MBean" +
+                                                  "if they are needed. Command: %s", command));
+    }
+}
diff --git a/src/java/org/apache/cassandra/profiler/AsyncProfilerUnsafe.java b/src/java/org/apache/cassandra/profiler/AsyncProfilerUnsafe.java
new file mode 100644
index 000000000000..10d12257760b
--- /dev/null
+++ b/src/java/org/apache/cassandra/profiler/AsyncProfilerUnsafe.java
@@ -0,0 +1,27 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.cassandra.profiler;
+
+public class AsyncProfilerUnsafe extends AsyncProfiler
+{
+    public void execute(String command)
+    {
+        getService().execute(command);
+    }
+}
diff --git a/src/java/org/apache/cassandra/service/CassandraDaemon.java b/src/java/org/apache/cassandra/service/CassandraDaemon.java
index 2f85e6e58eba..ed22fe4952e5 100644
--- a/src/java/org/apache/cassandra/service/CassandraDaemon.java
+++ b/src/java/org/apache/cassandra/service/CassandraDaemon.java
@@ -39,6 +39,8 @@
 
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.collect.ImmutableList;
+import org.apache.cassandra.profiler.AsyncProfiler;
+import org.apache.cassandra.profiler.AsyncProfilerMBean;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -74,6 +76,8 @@
 import org.apache.cassandra.io.util.FileUtils;
 import org.apache.cassandra.locator.InetAddressAndPort;
 import org.apache.cassandra.locator.Locator;
+import org.apache.cassandra.profiler.AsyncProfilerSafe;
+import org.apache.cassandra.profiler.AsyncProfilerUnsafe;
 import org.apache.cassandra.tcm.CMSOperations;
 import org.apache.cassandra.tcm.ClusterMetadataService;
 import org.apache.cassandra.tcm.RegistrationStatus;
@@ -104,6 +108,7 @@
 import org.apache.cassandra.utils.logging.VirtualTableAppender;
 
 import static java.util.concurrent.TimeUnit.NANOSECONDS;
+import static org.apache.cassandra.config.CassandraRelevantProperties.ASYNC_PROFILER_ADVANCED_MODE;
 import static org.apache.cassandra.config.CassandraRelevantProperties.CASSANDRA_FOREGROUND;
 import static org.apache.cassandra.config.CassandraRelevantProperties.CASSANDRA_PID_FILE;
 import static org.apache.cassandra.config.CassandraRelevantProperties.COM_SUN_MANAGEMENT_JMXREMOTE_PORT;
@@ -751,6 +756,7 @@ public void activate(boolean closeStdOutErr)
             applyConfig();
 
             registerNativeAccess();
+            registerAsyncProfiler();
 
             setup();
 
@@ -803,6 +809,21 @@ public static void registerNativeAccess() throws javax.management.NotCompliantMB
         MBeanWrapper.instance.registerMBean(new StandardMBean(new NativeAccess(), NativeAccessMBean.class), MBEAN_NAME, MBeanWrapper.OnException.LOG);
     }
 
+    @VisibleForTesting
+    public static void registerAsyncProfiler() throws javax.management.NotCompliantMBeanException
+    {
+        AsyncProfiler asyncProfiler;
+        if (!ASYNC_PROFILER_ADVANCED_MODE.getBoolean())
+        {
+            asyncProfiler = new AsyncProfilerSafe();
+        }
+        else
+        {
+            asyncProfiler = new AsyncProfilerUnsafe();
+        }
+        MBeanWrapper.instance.registerMBean(new StandardMBean(asyncProfiler, AsyncProfilerMBean.class), AsyncProfiler.MBEAN_NAME, MBeanWrapper.OnException.LOG);
+    }
+
     public void applyConfig()
     {
         DatabaseDescriptor.daemonInitialization();
diff --git a/src/java/org/apache/cassandra/tools/NodeProbe.java b/src/java/org/apache/cassandra/tools/NodeProbe.java
index 38e5a9557ae2..df6b1a825f49 100644
--- a/src/java/org/apache/cassandra/tools/NodeProbe.java
+++ b/src/java/org/apache/cassandra/tools/NodeProbe.java
@@ -117,6 +117,8 @@
 import org.apache.cassandra.metrics.ThreadPoolMetrics;
 import org.apache.cassandra.net.MessagingService;
 import org.apache.cassandra.net.MessagingServiceMBean;
+import org.apache.cassandra.profiler.AsyncProfiler;
+import org.apache.cassandra.profiler.AsyncProfilerMBean;
 import org.apache.cassandra.service.ActiveRepairServiceMBean;
 import org.apache.cassandra.service.AutoRepairService;
 import org.apache.cassandra.service.AutoRepairServiceMBean;
@@ -187,6 +189,7 @@ public class NodeProbe implements AutoCloseable
     protected PermissionsCacheMBean pcProxy;
     protected RolesCacheMBean rcProxy;
     protected AutoRepairServiceMBean autoRepairProxy;
+    protected AsyncProfilerMBean asyncProfilerProxy;
     protected GuardrailsMBean grProxy;
     protected volatile Output output;
 
@@ -335,6 +338,9 @@ protected void connect() throws IOException
             name = new ObjectName(AutoRepairService.MBEAN_NAME);
             autoRepairProxy = JMX.newMBeanProxy(mbeanServerConn, name, AutoRepairServiceMBean.class);
 
+            name = new ObjectName(AsyncProfiler.MBEAN_NAME);
+            asyncProfilerProxy = JMX.newMBeanProxy(mbeanServerConn, name, AsyncProfilerMBean.class);
+
             name = new ObjectName(Guardrails.MBEAN_NAME);
             grProxy = JMX.newMBeanProxy(mbeanServerConn, name, GuardrailsMBean.class);
         }
@@ -1329,6 +1335,11 @@ public AccordOperationsMBean getAccordOperationsProxy()
         return accordProxy;
     }
 
+    public AsyncProfilerMBean getAsyncProfilerProxy()
+    {
+        return asyncProfilerProxy;
+    }
+
     public GossiperMBean getGossProxy()
     {
         return gossProxy;
diff --git a/src/java/org/apache/cassandra/tools/nodetool/NodetoolCommand.java b/src/java/org/apache/cassandra/tools/nodetool/NodetoolCommand.java
index 98793e2748e3..f0036cbadeb9 100644
--- a/src/java/org/apache/cassandra/tools/nodetool/NodetoolCommand.java
+++ b/src/java/org/apache/cassandra/tools/nodetool/NodetoolCommand.java
@@ -149,6 +149,7 @@
                          NetStats.class,
                          PauseHandoff.class,
                          ProfileLoad.class,
+                         Profile.class,
                          ProxyHistograms.class,
                          RangeKeySample.class,
                          Rebuild.class,
diff --git a/src/java/org/apache/cassandra/tools/nodetool/Profile.java b/src/java/org/apache/cassandra/tools/nodetool/Profile.java
new file mode 100644
index 000000000000..681960de19b6
--- /dev/null
+++ b/src/java/org/apache/cassandra/tools/nodetool/Profile.java
@@ -0,0 +1,122 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.cassandra.tools.nodetool;
+
+import java.time.ZoneId;
+import java.time.format.DateTimeFormatter;
+
+import org.apache.cassandra.tools.NodeProbe;
+import org.apache.cassandra.profiler.AsyncProfilerMBean;
+
+import org.apache.cassandra.utils.FBUtilities;
+import picocli.CommandLine.Command;
+import picocli.CommandLine.Option;
+
+@Command(name = "profile", description = "Manage Async-Profiler on the cassandra process",
+         subcommands = {
+            Profile.Start.class,
+            Profile.Stop.class,
+            Profile.Raw.class
+         })
+public class Profile extends AbstractCommand
+{
+    @Override
+    public void execute(NodeProbe probe) {
+        AbstractCommand cmd = new Start();
+        cmd.probe(probe);
+        cmd.logger(output);
+        cmd.run();
+    }
+
+    @Command(name = "start", description = "Run Async-Profiler on the cassandra process")
+    public static class Start extends AbstractCommand
+    {
+
+        @Option(names = {"-e", "--event"}, description = "Event to profile (cpu, alloc, lock, wall, etc.)")
+        public String event = "cpu";
+
+        @Option(names = {"-o", "--output"}, description = "File Name")
+        public String filename = DateTimeFormatter.ofPattern("yyyy-MM-dd-HH-mm-ss")
+                                                  .withZone(ZoneId.systemDefault()).format(FBUtilities.now()) + ".html";
+
+        @Option(names = {"-t", "--timeout"}, description = "Timeout in seconds")
+        public int timeout = 60;
+
+        @Option(names = {"-f", "--format"}, description = "Output format (flamegraph, tree, traces, etc.)")
+        public String outputFormat = "flamegraph";
+
+        @Override
+        protected void execute(NodeProbe probe)
+        {
+            AsyncProfilerMBean profiler = probe.getAsyncProfilerProxy();
+
+            if (!profiler.isAvailable()) {
+                System.err.println("Async-profiler native library is not loaded or unavailable.");
+                return;
+            }
+
+            System.out.printf("Starting async-profiler: event=%s, format=%s\n", event, outputFormat);
+            profiler.start(event, outputFormat, timeout, filename);
+        }
+    }
+
+    @Command(name = "stop", description = "Stop Async-Profiler on the cassandra process")
+    public static class Stop extends AbstractCommand
+    {
+        @Option(names = {"-o", "--output"}, description = "File Name")
+        public String filename = DateTimeFormatter.ofPattern("yyyy-MM-dd-HH-mm-ss")
+                                                  .withZone(ZoneId.systemDefault()).format(FBUtilities.now()) + ".html";
+
+        @Override
+        protected void execute(NodeProbe probe)
+        {
+            AsyncProfilerMBean profiler = probe.getAsyncProfilerProxy();
+
+            if (!profiler.isAvailable()) {
+                System.err.println("Async-profiler native library is not loaded or unavailable.");
+                return;
+            }
+
+            System.out.printf("Stopping profiler\n");
+            profiler.stop(filename);
+        }
+    }
+
+    @Command(name = "raw", description = "Execute an arbitrary command on Async-Profiler on the cassandra process")
+    public static class Raw extends AbstractCommand
+    {
+
+        @Option(names = {"-c", "--command"}, description = "Raw commands to execute")
+        public String command;
+
+        @Override
+        protected void execute(NodeProbe probe)
+        {
+            AsyncProfilerMBean profiler = probe.getAsyncProfilerProxy();
+
+            if (!profiler.isAvailable()) {
+                System.err.println("Async-profiler native library is not loaded or unavailable.");
+                return;
+            }
+
+            System.out.printf("Executing raw command: %s\n", command);
+            profiler.execute(command);
+        }
+    }
+}
diff --git a/src/java/org/apache/cassandra/tools/profiler/AsyncProfilerService.java b/src/java/org/apache/cassandra/tools/profiler/AsyncProfilerService.java
new file mode 100644
index 000000000000..875a8fc1cd63
--- /dev/null
+++ b/src/java/org/apache/cassandra/tools/profiler/AsyncProfilerService.java
@@ -0,0 +1,166 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.cassandra.tools.profiler;
+
+import one.profiler.AsyncProfiler;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.Arrays;
+import java.util.Set;
+import java.util.regex.Pattern;
+
+import static org.apache.cassandra.config.CassandraRelevantProperties.ASYNC_PROFILER_ENABLED;
+import static org.apache.cassandra.config.CassandraRelevantProperties.ASYNC_PROFILER_OUTPUT_DIRECTORY;
+
+public class AsyncProfilerService
+{
+    private static final Logger logger = LoggerFactory.getLogger(AsyncProfilerService.class);
+
+    private static final Set<String> VALID_EVENTS = Set.of("cpu", "alloc", "lock", "wall", "nativemem", "cache-misses");
+    private static final Set<String> VALID_FORMATS = Set.of("flat","traces","collapsed","flamegraph","tree","jfr","otlp");
+
+    private static final Pattern VALID_FILENAME_REGEX_PATTERN = Pattern.compile("^[a-zA-Z0-9-]*\\.?[a-zA-Z0-9-]*$");
+
+    private static AsyncProfiler profilerInstance;
+
+    static
+    {
+        try
+        {
+            // Let async-profiler automatically extract and load the native library from the JAR
+            profilerInstance = AsyncProfiler.getInstance();
+        }
+        catch (Throwable t)
+        {
+            logger.error("async-profiler initialization ERROR");
+            profilerInstance = null;
+        }
+    }
+
+    public void start(String event, String outputFormat, int timeout, String outputFileName)
+    {
+        checkProfilerInstance();
+        validateEvent(event);
+        validateFormat(outputFormat);
+        validateOutputFileName(outputFileName);
+        String outputPath = Path.of(ASYNC_PROFILER_OUTPUT_DIRECTORY.getString(), outputFileName).toString();
+        try
+        {
+            String cmd = String.format("start,%s,event=%s,timeout=%s,file=%s",
+                                       outputFormat,
+                                       event,
+                                       timeout,
+                                       outputPath);
+
+            profilerInstance.execute(cmd);
+            logger.info("Started async-profiler: cmd={}", cmd);
+        }
+        catch (IOException e)
+        {
+            logger.error("Failed to start async-profiler", e);
+            throw new RuntimeException(e);
+        }
+    }
+
+    public void stop(String outputFileName)
+    {
+        checkProfilerInstance();
+        validateOutputFileName(outputFileName);
+
+        String outputPath = Path.of(ASYNC_PROFILER_OUTPUT_DIRECTORY.getString(), outputFileName).toString();
+
+        String cmd = String.format("stop,file=%s",
+                                   outputPath);
+
+        try
+        {
+            profilerInstance.execute(cmd);
+            logger.info("Stopped async-profiler: cmd={}", cmd);
+        } catch (IOException e)
+        {
+            logger.error("Failed to stop async-profiler", e);
+            throw new RuntimeException(e);
+        }
+    }
+
+    public void execute(String command)
+    {
+        checkProfilerInstance();
+
+        try
+        {
+            profilerInstance.execute(command);
+            logger.info("Executed raw async-profiler command {}", command);
+        }
+        catch (IOException e)
+        {
+            logger.error("Failed to execute raw async-profiler command {}", command, e);
+            throw new RuntimeException(e);
+        }
+    }
+
+    public boolean isAvailable()
+    {
+        return profilerInstance != null;
+    }
+
+    private void checkProfilerInstance()
+    {
+        if (ASYNC_PROFILER_ENABLED.getBoolean() == false)
+        {
+            throw new IllegalStateException("async-profiler is not enabled.");
+        }
+        else if (!isAvailable())
+        {
+            throw new IllegalStateException("async-profiler is not initialized.");
+        }
+    }
+
+    private void validateEvent(String event)
+    {
+        if (!Arrays.stream(event.split(",")).filter(s -> !s.isEmpty()).allMatch(VALID_EVENTS::contains))
+        {
+            throw new IllegalArgumentException(String.format("Event must be one or a combination of %s", VALID_EVENTS.toString()));
+        }
+    }
+
+    private void validateFormat(String format)
+    {
+        if (!VALID_FORMATS.contains(format))
+        {
+            throw new IllegalArgumentException(String.format("Format must be one or a combination of %s", VALID_FORMATS.toString()));
+        }
+    }
+
+    private void validateOutputFileName(String outputFile)
+    {
+        if (outputFile == null || outputFile.trim().isEmpty())
+        {
+            throw new IllegalArgumentException("Output file name must not be null or empty.");
+        }
+
+        if (!VALID_FILENAME_REGEX_PATTERN.matcher(outputFile).matches())
+        {
+            throw new IllegalArgumentException(String.format("Output file name must match pattern %s", VALID_FILENAME_REGEX_PATTERN));
+        }
+    }
+}
diff --git a/test/resources/nodetool/help/nodetool b/test/resources/nodetool/help/nodetool
index b0301217f647..a06157ea8794 100644
--- a/test/resources/nodetool/help/nodetool
+++ b/test/resources/nodetool/help/nodetool
@@ -97,6 +97,7 @@ The most commonly used nodetool commands are:
     move                                Move node on the token ring to a new token
     netstats                            Print network information on provided host (connecting node by default)
     pausehandoff                        Pause hints delivery process
+    profile                             Manage Async-Profiler on the cassandra process
     profileload                         Low footprint profiling of activity for a period of time
     proxyhistograms                     Print statistic histograms for network operations
     rangekeysample                      Shows the sampled keys held across all keyspaces
diff --git a/test/resources/nodetool/help/profile b/test/resources/nodetool/help/profile
new file mode 100644
index 000000000000..ae11b1a6d6aa
--- /dev/null
+++ b/test/resources/nodetool/help/profile
@@ -0,0 +1,70 @@
+NAME
+        nodetool profile - Manage Async-Profiler on the cassandra process
+
+SYNOPSIS
+        nodetool [(-h <host> | --host <host>)] [(-p <port> | --port <port>)]
+                [(-pp | --print-port)] [(-pw <password> | --password <password>)]
+                [(-pwf <passwordFilePath> | --password-file <passwordFilePath>)]
+                [(-u <username> | --username <username>)] profile <command> [<args>]
+
+        nodetool [(-h <host> | --host <host>)] [(-p <port> | --port <port>)]
+                [(-pp | --print-port)] [(-pw <password> | --password <password>)]
+                [(-pwf <passwordFilePath> | --password-file <passwordFilePath>)]
+                [(-u <username> | --username <username>)] profile start
+                [(-e <event> | --event <event>)]
+                [(-f <outputFormat> | --format <outputFormat>)]
+                [(-o <filename> | --output <filename>)]
+                [(-t <timeout> | --timeout <timeout>)]
+
+        nodetool [(-h <host> | --host <host>)] [(-p <port> | --port <port>)]
+                [(-pp | --print-port)] [(-pw <password> | --password <password>)]
+                [(-pwf <passwordFilePath> | --password-file <passwordFilePath>)]
+                [(-u <username> | --username <username>)] profile stop
+                [(-o <filename> | --output <filename>)]
+
+        nodetool [(-h <host> | --host <host>)] [(-p <port> | --port <port>)]
+                [(-pp | --print-port)] [(-pw <password> | --password <password>)]
+                [(-pwf <passwordFilePath> | --password-file <passwordFilePath>)]
+                [(-u <username> | --username <username>)] profile raw
+                [(-c <command> | --command <command>)]
+
+OPTIONS
+        -h <host>, --host <host>
+            Node hostname or ip address
+
+        -p <port>, --port <port>
+            Remote jmx agent port number
+
+        -pp, --print-port
+            Operate in 4.0 mode with hosts disambiguated by port number
+
+        -pw <password>, --password <password>
+            Remote jmx agent password
+
+        -pwf <passwordFilePath>, --password-file <passwordFilePath>
+            Path to the JMX password file
+
+        -u <username>, --username <username>
+            Remote jmx agent username
+
+COMMANDS
+        With no arguments, Display help information
+
+        start
+            Run Async-Profiler on the cassandra process
+
+            With --event option, Event to profile (cpu, alloc, lock, wall, etc.)
+
+            With --output option, File Name
+
+            With --timeout option, Timeout in seconds
+
+            With --format option, Output format (flamegraph, tree, traces, etc.)
+        stop
+            Stop Async-Profiler on the cassandra process
+
+            With --output option, File Name
+        raw
+            Execute an arbitrary command on Async-Profiler on the cassandra process
+
+            With --command option, Raw commands to execute
diff --git a/test/resources/nodetool/help/profile$raw b/test/resources/nodetool/help/profile$raw
new file mode 100644
index 000000000000..7554e4c6d51b
--- /dev/null
+++ b/test/resources/nodetool/help/profile$raw
@@ -0,0 +1,32 @@
+NAME
+        nodetool profile raw - Execute an arbitrary command on Async-Profiler
+        on the cassandra process
+
+SYNOPSIS
+        nodetool [(-h <host> | --host <host>)] [(-p <port> | --port <port>)]
+                [(-pp | --print-port)] [(-pw <password> | --password <password>)]
+                [(-pwf <passwordFilePath> | --password-file <passwordFilePath>)]
+                [(-u <username> | --username <username>)] profile raw
+                [(-c <command> | --command <command>)]
+
+OPTIONS
+        -c <command>, --command <command>
+            Raw commands to execute
+
+        -h <host>, --host <host>
+            Node hostname or ip address
+
+        -p <port>, --port <port>
+            Remote jmx agent port number
+
+        -pp, --print-port
+            Operate in 4.0 mode with hosts disambiguated by port number
+
+        -pw <password>, --password <password>
+            Remote jmx agent password
+
+        -pwf <passwordFilePath>, --password-file <passwordFilePath>
+            Path to the JMX password file
+
+        -u <username>, --username <username>
+            Remote jmx agent username
diff --git a/test/resources/nodetool/help/profile$start b/test/resources/nodetool/help/profile$start
new file mode 100644
index 000000000000..6241346be8ff
--- /dev/null
+++ b/test/resources/nodetool/help/profile$start
@@ -0,0 +1,43 @@
+NAME
+        nodetool profile start - Run Async-Profiler on the cassandra process
+
+SYNOPSIS
+        nodetool [(-h <host> | --host <host>)] [(-p <port> | --port <port>)]
+                [(-pp | --print-port)] [(-pw <password> | --password <password>)]
+                [(-pwf <passwordFilePath> | --password-file <passwordFilePath>)]
+                [(-u <username> | --username <username>)] profile start
+                [(-e <event> | --event <event>)]
+                [(-f <outputFormat> | --format <outputFormat>)]
+                [(-o <filename> | --output <filename>)]
+                [(-t <timeout> | --timeout <timeout>)]
+
+OPTIONS
+        -e <event>, --event <event>
+            Event to profile (cpu, alloc, lock, wall, etc.)
+
+        -f <outputFormat>, --format <outputFormat>
+            Output format (flamegraph, tree, traces, etc.)
+
+        -h <host>, --host <host>
+            Node hostname or ip address
+
+        -o <filename>, --output <filename>
+            File Name
+
+        -p <port>, --port <port>
+            Remote jmx agent port number
+
+        -pp, --print-port
+            Operate in 4.0 mode with hosts disambiguated by port number
+
+        -pw <password>, --password <password>
+            Remote jmx agent password
+
+        -pwf <passwordFilePath>, --password-file <passwordFilePath>
+            Path to the JMX password file
+
+        -t <timeout>, --timeout <timeout>
+            Timeout in seconds
+
+        -u <username>, --username <username>
+            Remote jmx agent username
diff --git a/test/resources/nodetool/help/profile$stop b/test/resources/nodetool/help/profile$stop
new file mode 100644
index 000000000000..bee5e4d6faa1
--- /dev/null
+++ b/test/resources/nodetool/help/profile$stop
@@ -0,0 +1,31 @@
+NAME
+        nodetool profile stop - Stop Async-Profiler on the cassandra process
+
+SYNOPSIS
+        nodetool [(-h <host> | --host <host>)] [(-p <port> | --port <port>)]
+                [(-pp | --print-port)] [(-pw <password> | --password <password>)]
+                [(-pwf <passwordFilePath> | --password-file <passwordFilePath>)]
+                [(-u <username> | --username <username>)] profile stop
+                [(-o <filename> | --output <filename>)]
+
+OPTIONS
+        -h <host>, --host <host>
+            Node hostname or ip address
+
+        -o <filename>, --output <filename>
+            File Name
+
+        -p <port>, --port <port>
+            Remote jmx agent port number
+
+        -pp, --print-port
+            Operate in 4.0 mode with hosts disambiguated by port number
+
+        -pw <password>, --password <password>
+            Remote jmx agent password
+
+        -pwf <passwordFilePath>, --password-file <passwordFilePath>
+            Path to the JMX password file
+
+        -u <username>, --username <username>
+            Remote jmx agent username
diff --git a/test/unit/org/apache/cassandra/tools/AsyncProfilerServiceTest.java b/test/unit/org/apache/cassandra/tools/AsyncProfilerServiceTest.java
new file mode 100644
index 000000000000..5f3eba7e2e9f
--- /dev/null
+++ b/test/unit/org/apache/cassandra/tools/AsyncProfilerServiceTest.java
@@ -0,0 +1,201 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.cassandra.tools;
+
+import java.io.File;
+import java.nio.file.Path;
+import java.util.UUID;
+
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.After;
+import org.junit.Test;
+
+import org.apache.cassandra.io.util.FileUtils;
+import org.apache.cassandra.tools.profiler.AsyncProfilerService;
+
+import static org.apache.cassandra.config.CassandraRelevantProperties.ASYNC_PROFILER_OUTPUT_DIRECTORY;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import static org.apache.cassandra.config.CassandraRelevantProperties.ASYNC_PROFILER_ENABLED;
+import static org.apache.cassandra.config.CassandraRelevantProperties.ASYNC_PROFILER_ADVANCED_MODE;
+
+public class AsyncProfilerServiceTest
+{
+
+    private static AsyncProfilerService profiler;
+    private String testOutputFile;
+    private static final String testOutputPath = FileUtils.getTempDir().path();
+
+    @BeforeClass
+    public static void setUpClass()
+    {
+        profiler = new AsyncProfilerService();
+
+        if (!profiler.isAvailable())
+        {
+            fail("AsyncProfilerService could not initialize (native lib not found or invalid).");
+        }
+    }
+
+    @Before
+    public void setUp()
+    {
+        ASYNC_PROFILER_ENABLED.setBoolean(true);
+        ASYNC_PROFILER_OUTPUT_DIRECTORY.setString(testOutputPath);
+        testOutputFile = UUID.randomUUID().toString();
+    }
+
+    @After
+    public void tearDown()
+    {
+        try
+        {
+            profiler.stop(testOutputFile);
+            File outputFile = new File(testOutputFile);
+            if (outputFile.exists())
+            {
+                outputFile.delete();
+            }
+        }
+        catch (Exception e)
+        {
+            // The only meaningful exception that can surface here is if profiler.start
+            // was not called prior to profiler.stop, we can safely ignore this.
+        }
+    }
+
+    @Test
+    public void testStartAndStopProfiling() {
+        try
+        {
+            profiler.start("cpu", "flamegraph", 10, testOutputFile + ".html");
+            Thread.sleep(2000);
+            profiler.stop(testOutputFile + ".html");
+        }
+        catch (Exception e)
+        {
+            fail("Profiling failed: " + e.getMessage());
+        }
+
+        File file = new File(Path.of(testOutputPath, testOutputFile + ".html").toString());
+
+        assertTrue("Output profile file should exist", file.exists());
+        assertTrue("Output profile file should not be empty", file.length() > 0);
+    }
+
+    @Test
+    public void testInvalidEventThrowsException()
+    {
+        try
+        {
+            profiler.start("not_a_real_event", "flamegraph", 60, testOutputFile);
+            fail("Expected RuntimeException due to invalid event");
+        }
+        catch (RuntimeException e)
+        {
+            assertNotNull(e.getMessage());
+            assertTrue("Invalid event should not start profiler", e.getMessage().contains("Event must be one or a combination of"));
+        }
+    }
+
+    @Test
+    public void testInvalidFormatThrowsException()
+    {
+        try
+        {
+            profiler.start("cpu", "not_a_real_format", 60, testOutputFile);
+            fail("Expected RuntimeException due to invalid format");
+        }
+        catch (RuntimeException e)
+        {
+            assertNotNull(e.getMessage());
+            assertTrue("Invalid format should not start profiler", e.getMessage().contains("Format must be one or a combination of"));
+        }
+    }
+
+    @Test
+    public void testInvalidOutputFileNameThrowsException()
+    {
+        try
+        {
+            profiler.start("cpu", "flamegraph", 60, "| grep test");
+            fail("Expected RuntimeException due to invalid output file name");
+        }
+        catch (Exception e)
+        {
+            assertNotNull(e.getMessage());
+            assertTrue("Invalid output file name", e.getMessage().contains("Output file name must match pattern"));
+        }
+    }
+
+    @Test
+    public void testMultipleStartCallsThrowsException()
+    {
+        try
+        {
+            profiler.start("cpu", "flamegraph", 60, testOutputFile);
+            profiler.start("cpu", "flamegraph", 60, testOutputFile);
+            fail("Expected IllegalStateException due to multiple start calls");
+        }
+        catch (IllegalStateException e)
+        {
+            assertNotNull(e.getMessage());
+            assertTrue("Process should not start another profiling job", e.getMessage().contains("Profiler already started"));
+        }
+    }
+
+    @Test
+    public void testProfilerDisabledThrowsException()
+    {
+        try
+        {
+            ASYNC_PROFILER_ENABLED.setBoolean(false);
+            profiler.execute(String.format("start,event=cpu"));
+            fail("Expected IllegalStateException due to disabled profiler");
+        }
+        catch (IllegalStateException e)
+        {
+            assertNotNull(e.getMessage());
+            assertTrue("ASYNC_PROFILER_ENABLED is false", e.getMessage().contains("async-profiler is not enabled."));
+        }
+    }
+
+    @Test
+    public void testAdvancedModeEnabledSuccess()
+    {
+        try
+        {
+            ASYNC_PROFILER_ADVANCED_MODE.setBoolean(true);
+            profiler.execute(String.format("start,event=cpu"));
+            Thread.sleep(5000);
+            profiler.execute(String.format("stop,file=%s", testOutputFile));
+        }
+        catch (Exception e)
+        {
+            fail("Profiling failed: " + e.getMessage());
+        }
+
+        File file = new File(testOutputFile);
+        assertTrue("Output profile file for advanced mode should exist", file.exists());
+        assertTrue("Output profile file for advanced mode should not be empty", file.length() > 0);
+    }
+}
diff --git a/test/unit/org/apache/cassandra/tools/AsyncProfilerTest.java b/test/unit/org/apache/cassandra/tools/AsyncProfilerTest.java
new file mode 100644
index 000000000000..ca797e7cf387
--- /dev/null
+++ b/test/unit/org/apache/cassandra/tools/AsyncProfilerTest.java
@@ -0,0 +1,65 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.cassandra.tools;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import org.apache.cassandra.profiler.AsyncProfiler;
+import org.apache.cassandra.profiler.AsyncProfilerSafe;
+import org.apache.cassandra.profiler.AsyncProfilerUnsafe;
+import static org.junit.Assert.fail;
+
+public class AsyncProfilerTest
+{
+    private static AsyncProfiler safeProfiler;
+    private static AsyncProfiler unsafeProfiler;
+
+    @BeforeClass
+    public static void setUpClass()
+    {
+        safeProfiler = new AsyncProfilerSafe();
+        unsafeProfiler = new AsyncProfilerUnsafe();
+    }
+
+    @Test
+    public void testUnsafeExecute() {
+        try
+        {
+            unsafeProfiler.execute("foo");
+        }
+        catch (Exception e)
+        {
+            fail("Profiling failed: " + e.getMessage());
+        }
+    }
+
+    @Test
+    public void testSafeExecute() {
+        try
+        {
+            safeProfiler.execute("foo");
+            fail("Execute command should fail");
+        }
+        catch (SecurityException e)
+        {
+            // Should fail
+        }
+    }
+}