diff --git a/wpilibNewCommands/build.gradle b/wpilibNewCommands/build.gradle
index 3b4693f5484..1e78c3712cc 100644
--- a/wpilibNewCommands/build.gradle
+++ b/wpilibNewCommands/build.gradle
@@ -104,4 +104,10 @@ test {
         outputs.upToDateWhen {false}
         showStandardStreams = true
     }
+    doFirst {
+        jvmArgs = [
+            '--add-opens', 'java.base/jdk.internal.vm=ALL-UNNAMED',
+            '--add-opens', 'java.base/java.lang=ALL-UNNAMED',
+        ]
+    }
 }
diff --git a/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj3/command/async/AsyncCommand.java b/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj3/command/async/AsyncCommand.java
index a6d346704b0..4479d3fc597 100644
--- a/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj3/command/async/AsyncCommand.java
+++ b/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj3/command/async/AsyncCommand.java
@@ -3,6 +3,8 @@
 import edu.wpi.first.units.Measure;
 import edu.wpi.first.units.Time;
 import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
 import java.util.Set;
 import java.util.stream.Collectors;
 
@@ -107,6 +109,17 @@ default boolean requires(HardwareResource resource) {
     return requirements().contains(resource);
   }
 
+  /**
+   * Checks if this command conflicts with another command.
+   *
+   * @param other the commands to check against
+   * @return true if both commands require at least one of the same resource, false if both commands
+   *   have completely different requirements
+   */
+  default boolean conflictsWith(AsyncCommand other) {
+    return !Collections.disjoint(requirements(), other.requirements());
+  }
+
   /**
    * Creates an async command that does not require any hardware; that is, it does not affect the
    * state of any physical objects. This is useful for commands that do some house cleaning work
@@ -126,7 +139,7 @@ default void schedule() {
 
   /** Cancels this command, if running on the default async scheduler. */
   default void cancel() {
-    AsyncScheduler.getInstance().cancelAndWait(this, true);
+    AsyncScheduler.getInstance().cancel(this);
   }
 
   /** Checks if this command is currently scheduled to be running on the default async scheduler. */
@@ -135,65 +148,20 @@ default boolean isScheduled() {
   }
 
   default AsyncCommand withTimeout(Measure<Time> timeout) {
-    final AsyncCommand original = this;
-
-    return new AsyncCommand() {
-      @Override
-      public void run() throws Exception {
-        AsyncScheduler.getInstance().schedule(AsyncCommand.noHardware(() -> {
-          AsyncCommand.pause(timeout);
-          AsyncScheduler.getInstance().cancelAndWait(this, true);
-        }).named("Timer for " + original.name()));
-
-        original.run();
-      }
-
-      @Override
-      public String name() {
-        return original.name();
-      }
-
-      @Override
-      public Set<HardwareResource> requirements() {
-        return original.requirements();
-      }
-
-      @Override
-      public int priority() {
-        return original.priority();
-      }
-
-      @Override
-      public RobotDisabledBehavior robotDisabledBehavior() {
-        return original.robotDisabledBehavior();
-      }
-    };
+    return ParallelGroup.race(name(), this, new WaitCommand(timeout));
   }
 
   static AsyncCommandBuilder requiring(HardwareResource requirement, HardwareResource... rest) {
     return new AsyncCommandBuilder().requiring(requirement).requiring(rest);
   }
 
-  /**
-   * Pauses the execution thread for the given duration. This is intended to be used by commands to
-   * pause themselves and allow other commands to run.
-   *
-   * @param duration how long the command should pause for. Shorter durations provide higher
-   *                 resolution for control loops, but incur higher CPU use and may cause contention
-   *                 if too many commands with low pause times are running concurrently.
-   * @throws InterruptedException if the command was interrupted by another command while paused
-   */
-  static void pause(Measure<Time> duration) throws InterruptedException {
-    AsyncScheduler.getInstance().pauseCurrentCommand(duration);
+  static void yield() {
+    AsyncScheduler.getInstance().yield();
   }
 
-  /**
-   * Pauses the execution thread for the {@link AsyncScheduler#DEFAULT_UPDATE_PERIOD default period}
-   * to allow commands to pause themselves and allow other commands to run.
-   *
-   * @throws InterruptedException if the command was interrupted by another command while paused.
-   */
-  static void pause() throws InterruptedException {
-    AsyncCommand.pause(AsyncScheduler.DEFAULT_UPDATE_PERIOD);
+  static void park() {
+    while (true) {
+      AsyncCommand.yield();
+    }
   }
 }
diff --git a/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj3/command/async/AsyncRobot.java b/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj3/command/async/AsyncRobot.java
deleted file mode 100644
index 2988c6b600b..00000000000
--- a/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj3/command/async/AsyncRobot.java
+++ /dev/null
@@ -1,69 +0,0 @@
-package edu.wpi.first.wpilibj3.command.async;
-
-import static edu.wpi.first.units.Units.Milliseconds;
-import static edu.wpi.first.units.Units.Nanoseconds;
-import static edu.wpi.first.units.Units.Seconds;
-
-import edu.wpi.first.units.Measure;
-import edu.wpi.first.units.Time;
-import edu.wpi.first.wpilibj.IterativeRobotBase;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.Executors;
-import java.util.concurrent.atomic.AtomicBoolean;
-
-public class AsyncRobot extends IterativeRobotBase {
-  public static final Measure<Time> DEFAULT_PERIOD = Milliseconds.of(20);
-  private final Measure<Time> period;
-  protected final AsyncScheduler scheduler;
-
-  private final AtomicBoolean ended = new AtomicBoolean(false);
-
-  public AsyncRobot(Measure<Time> period, AsyncScheduler scheduler) {
-    super(period.in(Seconds));
-    this.period = period;
-    this.scheduler = scheduler;
-  }
-
-  public AsyncRobot() {
-    this(DEFAULT_PERIOD, AsyncScheduler.getInstance());
-  }
-
-  @Override
-  public void startCompetition() {
-    var future =
-        Executors
-            .newThreadPerTaskExecutor(Thread.ofVirtual().name("main vthread").factory())
-            .submit(() -> {
-              robotInit();
-
-              while (!ended.get()) {
-                sleep();
-
-                loopFunc();
-                scheduler.checkForErrors();
-              }
-
-              return null;
-            });
-
-    try {
-      future.get();
-    } catch (InterruptedException e) {
-      throw new RuntimeException("The main thread was interrupted while running your robot code!", e);
-    } catch (ExecutionException e) {
-      throw new RuntimeException("Robot's shouldn't quit, but yours did!", e);
-    }
-  }
-
-  @Override
-  public void endCompetition() {
-    ended.set(true);
-  }
-
-  private void sleep() throws InterruptedException {
-    long ms = (long) period.in(Milliseconds);
-    int ns = (int) (period.in(Nanoseconds) % 1e6);
-
-    Thread.sleep(ms, ns);
-  }
-}
diff --git a/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj3/command/async/AsyncScheduler.java b/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj3/command/async/AsyncScheduler.java
index 7a487821fb0..f5cd4f1f616 100644
--- a/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj3/command/async/AsyncScheduler.java
+++ b/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj3/command/async/AsyncScheduler.java
@@ -1,121 +1,61 @@
 package edu.wpi.first.wpilibj3.command.async;
 
-import static edu.wpi.first.units.Units.Microseconds;
-import static edu.wpi.first.units.Units.Milliseconds;
-import static edu.wpi.first.units.Units.Nanoseconds;
-
-import edu.wpi.first.units.Measure;
-import edu.wpi.first.units.Time;
-import edu.wpi.first.util.WPIUtilJNI;
 import edu.wpi.first.wpilibj.event.EventLoop;
-import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.Paths;
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
 import java.util.ArrayList;
-import java.util.Collection;
+import java.util.Collections;
 import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
-import java.util.Objects;
-import java.util.concurrent.Callable;
-import java.util.concurrent.CancellationException;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.Future;
-import java.util.concurrent.ThreadFactory;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
-import java.util.concurrent.atomic.AtomicLong;
-import java.util.concurrent.locks.ReadWriteLock;
-import java.util.concurrent.locks.ReentrantReadWriteLock;
+import java.util.Set;
 
 public class AsyncScheduler {
-  @interface Reads {}
-  @interface Writes {}
-  @interface NotLocking {}
+  private static final MethodHandle java_lang_thread_setContinuation;
 
   static {
-    String vthreadParallelism = System.getProperty("jdk.virtualThreadScheduler.parallelism");
-    if (!Objects.equals(vthreadParallelism, "1")) {
-      throw new ExceptionInInitializerError(
-          "The async command framework requires -Djdk.virtualThreadScheduler.parallelism=1, but was set to " + Objects.toString(vthreadParallelism));
+    try {
+      var lookup = MethodHandles.privateLookupIn(Thread.class, MethodHandles.lookup());
+
+      java_lang_thread_setContinuation = lookup.findVirtual(
+          Thread.class,
+          "setContinuation",
+          MethodType.methodType(void.class, Continuation.jdk_internal_vm_Continuation)
+      );
+    } catch (Throwable t) {
+      throw new ExceptionInInitializerError(t);
     }
   }
 
-  /**
-   * The default update period of async commands is 20 milliseconds by convention.
-   */
-  public static final Measure<Time> DEFAULT_UPDATE_PERIOD = Milliseconds.of(20);
-
-  private final Map<AsyncCommand, Throwable> errors = new HashMap<>();
-
   /**
    * The top-level running commands. This would include the highest-level command groups but not any
    * of their nested commands.
    */
-  private final Map<HardwareResource, AsyncCommand> runningCommands = new HashMap<>();
   private final Map<HardwareResource, AsyncCommand> defaultCommands = new HashMap<>();
-  private final Map<AsyncCommand, CommandState> commandStates = new HashMap<>();
+  private final Set<AsyncCommand> onDeck = new LinkedHashSet<>();
+  private final Map<AsyncCommand, CommandState> commandStates = new LinkedHashMap<>();
+  private final List<Continuation> periodicCallbacks = new ArrayList<>();
   private final EventLoop eventLoop = new EventLoop();
 
-  /**
-   * How long to wait for a command to be canceled before timing out and throwing an error. Defaults
-   * to 2.5ms.
-   */
-  public volatile Measure<Time> cancelTimeout = Microseconds.of(2500);
-  /**
-   * How long to wait for a command to start up after being scheduled before timing out and throwing
-   * an error. Defaults to 2ms.
-   */
-  public volatile Measure<Time> scheduleTimeout = Microseconds.of(2000);
+  private AsyncCommand currentCommand = null;
 
-  // NOTE: This requires the jdk.virtualThreadScheduler.parallelism system property to be set to 1!
-  //       If it is not set, or is set to a value > 1, then commands may be scheduled - at random -
-  //       to run on different threads, with all the race condition and resource contention problems
-  //       that entails. BE SURE TO SET `-Djdk.virtualThreadScheduler.parallelism=1` WHEN RUNNING A
-  //       ROBOT PROGRAM.
-  private final ThreadFactory factory =
-      Thread.ofVirtual().name("async-commands-runner-", 1).factory();
-  // Use a cached thread pool so we can guarantee one virtual thread per command
-  // When commands complete, their virtual threads will be reused by later commands
-  private final ExecutorService service = Executors.newCachedThreadPool(factory);
+  private final ContinuationScope scope = new ContinuationScope("async command");
 
-  private static final AsyncScheduler defaultScheduler = new AsyncScheduler();
+  private static AsyncScheduler defaultScheduler = new AsyncScheduler();
 
-  private final ReadWriteLock lock = new ReentrantReadWriteLock();
+  // package-private for tests
+  static void setDefaultScheduler(AsyncScheduler defaultScheduler) {
+    AsyncScheduler.defaultScheduler = defaultScheduler;
+  }
 
   public static AsyncScheduler getInstance() {
     return defaultScheduler;
   }
 
   public AsyncScheduler() {
-    this(Milliseconds.of(20));
-  }
-
-  public AsyncScheduler(Measure<Time> triggerPollingPeriod) {
-    this(triggerPollingPeriod, Milliseconds.of(2.5), Milliseconds.of(2.5));
-  }
-
-  public AsyncScheduler(Measure<Time> triggerPollingPeriod, Measure<Time> cancelTimeout, Measure<Time> scheduleTimeout) {
-    // Start polling the event loop
-    // This intentionally runs on the same carrier thread as commands so the boolean checks
-    // will be guaranteed to run on the same thread as the commands that manipulate state
-    addPeriodic(this::pollEventLoop);
-
-    this.cancelTimeout = cancelTimeout.copy();
-    this.scheduleTimeout = scheduleTimeout.copy();
-  }
-
-  private void pollEventLoop() {
-    try {
-      Thread.sleep(20);
-      eventLoop.poll();
-    } catch (Exception e) {
-      // ignore and keep running
-    }
   }
 
   public void registerResource(HardwareResource resource) {
@@ -137,8 +77,7 @@ public void setDefaultCommand(HardwareResource resource, AsyncCommand defaultCom
           "A resource's default command cannot require other resources");
     }
 
-    var oldDefaultCommand = defaultCommands.put(resource, defaultCommand);
-    cancelAndWait(oldDefaultCommand, false);
+    defaultCommands.put(resource, defaultCommand);
     schedule(defaultCommand);
   }
 
@@ -146,43 +85,27 @@ public AsyncCommand getDefaultCommand(HardwareResource resource) {
     return defaultCommands.get(resource);
   }
 
-  public void addPeriodic(ThrowingRunnable task, Measure<Time> period) {
-    long ms = (long) period.in(Milliseconds);
-    int ns = (int) (period.in(Nanoseconds) % 1e6);
+  public void sideload(Runnable callback) {
+    periodicCallbacks.add(new Continuation(scope, callback));
+  }
 
-    service.submit(() -> {
+  public void addPeriodic(Runnable callback) {
+    sideload(() -> {
       while (true) {
-        Thread.sleep(ms, ns);
-        task.run();
+        AsyncScheduler.this.yield();
+        callback.run();
       }
     });
   }
 
-  public void addPeriodic(ThrowingRunnable task) {
-    addPeriodic(task, DEFAULT_UPDATE_PERIOD);
-  }
-
-  @Reads
-  private boolean isSchedulable(AsyncCommand command) {
-    return Util.reading(lock, () -> {
-      // Don't schedule if a required resource is currently running a higher priority command
-      boolean shouldSchedule = true;
-      for (HardwareResource resource : command.requirements()) {
-        var runningCommand = runningCommands.get(resource);
-        if (command.isLowerPriorityThan(runningCommand)) {
-          shouldSchedule = false;
-          break;
-        }
-      }
-
-      if (shouldSchedule) {
-        Logger.log("SCHEDULE", "Command " + command.name() + " is higher priority than all conflicting commands. Cancelling the running commands");
-        return true;
-      } else {
-        Logger.log("SCHEDULE", "Lower priority than running commands, not scheduling");
-        return false;
-      }
-    });
+  public void scheduleComposed(AsyncCommand command, AsyncCommand parent) {
+    if (currentCommand == parent) {
+      // The parent command is currently executing; skip conflict checks
+      onDeck.add(command);
+    } else {
+      // The parent isn't currently running
+      schedule(command);
+    }
   }
 
   /**
@@ -190,424 +113,148 @@ private boolean isSchedulable(AsyncCommand command) {
    * checked later with {@link #isRunning(AsyncCommand)}. Scheduling will fail if the command has a
    * lower priority than a currently running command using one or more of the same resources.
    *
-   * <p>This method will block until the command has started to run. This may take between 0.1 and
-   * 2.0 milliseconds.
-   *
    * @param command the command to schedule
    */
-  @Writes
   public void schedule(AsyncCommand command) {
-    Logger.log("SCHEDULE", "Scheduling " + command.name());
-    final long start = System.nanoTime();
-
-    var currentState = Util.reading(lock, () -> commandStates.get(command));
-    if (currentState != null) {
-      Logger.log("SCHEDULE", "Command " + command.name() + " is already running (run ID=" + currentState.id + "), not rescheduling");
-      return;
+    Logger.log("SCHEDULE", "Attempting to schedule " + command);
+    for (AsyncCommand c : commandStates.keySet()) {
+      if (c.conflictsWith(command) && command.isLowerPriorityThan(c)) {
+        Logger.log("SCHEDULE", command + " conflicts with and is lower priority than " + c + ", not scheduling");
+        return;
+      }
     }
 
-    // Fire cancel requests on all conflicting commands (in a lock), then wait for them all to
-    // exit (outside the lock, to avoid contention with locking behavior in the cancellation cleanup)
-    // Then (in a lock again), create and schedule the carrier for the command, and (outside the
-    // lock), wait for the carrier to start up before finally returning from schedule().
-
-    var canceledCommandStates = new ArrayList<CommandState>();
-    boolean isSchedulable = Util.writing(
-        lock,
-        () -> {
-          if (!isSchedulable(command)) {
-            return false;
-          }
-
-          // Cancel the currently scheduled commands for each required resource and schedule the
-          // incoming command over them
-          for (HardwareResource resource : command.requirements()) {
-            var runningCommand = runningCommands.get(resource);
-
-            if (runningCommand != null) {
-              // Cancel the current command, but don't start the default command for the resource
-              // because we're about to start our own command that requires it
-              // Fire the event but don't wait for completion, because that will deadlock.
-              // Instead, after exiting this block, we wait for all the canceled commands to exit
-              // OUTSIDE the lock
-              canceledCommandStates.add(fireCancelEvent(runningCommand));
-            }
-
-            // Add to the running commands before we've technically scheduled it
-            // Cancelling a command will schedule default commands (which we don't want!) if the
-            // cancelled command is still mapped to a resource
-            runningCommands.put(resource, command);
-          }
-          return true;
-        });
-
-    if (!isSchedulable) {
-      // Not schedulable, bail
-      return;
+    for (var scheduledCommand : onDeck) {
+      if (!command.conflictsWith(scheduledCommand)) {
+        // No shared requirements, skip
+        continue;
+      }
+      if (command.isLowerPriorityThan(scheduledCommand)) {
+        // Lower priority than an already-scheduled (but not yet running) command that requires at
+        // one of the same resource
+        Logger.log("SCHEDULE", command + " is lower priority than already-scheduled command " + scheduledCommand + ", not scheduling");
+        return;
+      }
     }
 
-    // Wait for cancellation OUTSIDE the lock
-    // NOTE: If the lock is owned by the current thread, this has the potential to deadlock!
-    awaitBulkCancellation(canceledCommandStates);
+    // Evict conflicting on-deck commands
+    // We check above if the input command is lower priority than any of these,
+    // so at this point we're guaranteed to be >= priority than anything already on deck
+    onDeck.removeIf(c -> c.conflictsWith(command));
 
-    var newCommandStates = fireScheduleEvent(command);
+    Logger.log("SCHEDULE", "Adding " + command + " to on deck commands");
+    onDeck.add(command);
 
-    // Wait for the command to have started before returning
-    // Note: this may take up to 1 or 2 milliseconds! Normally seen on the order of ~0.1ms
-    try {
-      awaitBulkSchedulation(List.of(newCommandStates));
-    } finally {
-      long end = System.nanoTime();
-      Logger.log("SCHEDULE", "Took " + (end - start) / 1e3 + " µs to schedule " + command.name() + " (assigned run ID=" + newCommandStates.id + ")");
-    }
+    Logger.log("SCHEDULE", "Dropping commands that conflict with " + command);
+    commandStates.entrySet().removeIf(e -> e.getKey().conflictsWith(command));
   }
 
-  @NotLocking
-  private void awaitBulkSchedulation(Collection<CommandState> scheduledCommandStates) {
-    try {
-      CompletableFuture
-          .allOf(scheduledCommandStates.stream().map(s -> s.schedule).toArray(CompletableFuture[]::new))
-          .get((long) scheduleTimeout.in(Nanoseconds), TimeUnit.NANOSECONDS);
-    } catch (InterruptedException e) {
-      throw new IllegalStateException("Interrupted while waiting for all commands to start", e);
-    } catch (ExecutionException e) {
-      // Shouldn't happen, the "schedule" future is marked complete before the command begins to execute
-      throw new IllegalStateException("One or more scheduled commands encountered an internal exception", e.getCause());
-    } catch (TimeoutException e) {
-      var unscheduled = scheduledCommandStates.stream().filter(s -> !s.schedule.isDone()).map(s -> s.command.name() + " (run ID=" + s.id + ")").toList();
-      String message = "Timed out while waiting for all scheduled commands to start. Still waiting on: " + unscheduled + ". Locks: " + Util.owners();
-      Logger.log("AWAIT BULK SCHEDULATION", message);
-      try {
-        Files.writeString(Paths.get("thread-dump.txt"), Logger.formattedLogTable());
-      } catch (IOException ignore) {}
-      throw new IllegalStateException(message, e);
-    }
+  public void cancel(AsyncCommand command) {
+    // Evict the command. The next call to run() will schedule the default command for all its
+    // required resources, unless another command requiring those resources is scheduled between
+    // calling cancel() and calling run()
+    commandStates.remove(command);
   }
 
-  private void awaitBulkCancellation(Collection<CommandState> canceledCommandStates) {
-    try {
-      CompletableFuture
-          .allOf(canceledCommandStates.stream().map(s -> s.completion).toArray(CompletableFuture[]::new))
-          .get((long) cancelTimeout.in(Nanoseconds), TimeUnit.NANOSECONDS);
-    } catch (InterruptedException e) {
-      throw new IllegalStateException("Interrupted while waiting for all commands to cancel", e);
-    } catch (ExecutionException e) {
-      throw new IllegalStateException("One or more canceled commands encountered an internal exception", e.getCause());
-    } catch (TimeoutException e) {
-      var stillRunning = canceledCommandStates.stream().filter(s -> !s.completion.isDone()).map(s -> s.command.name() + " (run ID=" + s.id + ")").toList();
-      String message = "Timed out while waiting for all cancelled commands to complete. Still running: " + stillRunning + ". Locks: " + Util.owners();
-      Logger.log("AWAIT BULK CANCELLATION", message);
-      try {
-        Files.writeString(Paths.get("thread-dump.txt"), Logger.formattedLogTable());
-      } catch (IOException ignore) {}
-      throw new IllegalStateException(message, e);
-    }
-  }
+  private int runNum = 0;
 
-  /**
-   * Checks for errors that have been thrown by the asynchronous commands. This will clear the
-   * cached errors, and any errors were present, those errors will immediately be rethrown
-   */
-  public void checkForErrors() {
-    var errors =
-        Util.writing(
-            lock,
-            () -> {
-              var copy = Map.copyOf(this.errors);
-              this.errors.clear();
-              return copy;
-            });
-    if (errors.isEmpty()) {
-      // No errors, all good
-      return;
-    }
-    if (errors.size() == 1) {
-      // Just a single error, wrap and rethrow that on its own
-      var e = errors.entrySet().iterator().next();
-      throw new CommandExecutionException(e.getKey(), e.getValue());
+  public void run() {
+    runNum++;
+    Logger.log("RUN", "Starting run #" + runNum);
+    // Apply scheduled commands, evicting any commands that require the same resources
+    // Priority checking is done at schedule time so we don't need to repeat those checks here
+    // Note that if multiple commands are scheduled in the same loop that use the same resources,
+    // then the final scheduled command will win out.
+    for (var command : onDeck) {
+      Logger.log("RUN", "Building continuation for " + command);
+      commandStates.put(command, new CommandState(command, buildContinuation(command)));
     }
 
-    // Multiple errors were thrown since the last check, wrap them all in a MultiException and throw
-    // that
-    var multi = new MultiException();
-    errors.forEach((command, error) -> multi.add(new CommandExecutionException(command, error)));
-    throw multi;
-  }
+    // Clear the set of on-deck commands,
+    // since we just put them all into the set of running commands
+    Logger.log("RUN", "Clearing scheduled commands");
+    onDeck.clear();
 
-  private static final Object COMPLETED_VALUE = new Object();
+    Logger.log("RUN", "Executing periodic callbacks");
+    for (Continuation callback : periodicCallbacks) {
+      callback.run();
+    }
 
-  /**
-   * Creates a wrapper callback that manages execution of an async command and the associated
-   * cleanup after it completes or is cancelled.
-   *
-   * @param command the command to wrap
-   * @return a callback that can be scheduled on an executor service
-   */
-  private Callable<?> createCommandExecutorCallback(AsyncCommand command, CommandState state) {
-    return () -> {
-      long runId = state.id;
-      Logger.log("COMMAND", "Starting up vthread for command " + command.name() + " (run ID=" + runId + ")");
-
-      boolean wasInterrupted = false;
-      Object result = null;
-      Throwable exception = null;
-      try {
-        Logger.log("COMMAND", "Alerting scheduler about command startup for " + command.name() + " (run ID=" + runId + ")");
-        Util.writing(lock, () -> {
-          Logger.log("COMMAND", "Setting thread local command owner to " + command.name() + " (run ID=" + runId + ")");
-          commandOnCurrentThread.set(state);
+    periodicCallbacks.removeIf(Continuation::isDone);
 
-          Logger.log("COMMAND", "Completing the schedule future for " + command.name() + " (run ID=" + runId + ")");
-          state.schedule.complete(true);
-        });
+    // Tick every command that hasn't been completed yet
+    Logger.log("RUN", "Updating commands (" + commandStates.keySet() + ")");
+    for (var entry : List.copyOf(commandStates.entrySet())) {
+      final var command = entry.getKey();
+      Continuation continuation = entry.getValue().continuation;
 
-        Logger.log("COMMAND", "Starting execution for " + command.name() + " (run ID=" + runId + ")");
-        long start = System.nanoTime();
-        command.run();
-        long end = System.nanoTime();
-        Logger.log("COMMAND", command + " completed naturally in " + (end - start) / 1e3 + " µs" + " (run ID=" + runId + ")");
-        result = COMPLETED_VALUE;
-        return null;
-      } catch (Throwable e) {
-        if (e instanceof InterruptedException) {
-          // Cancelled during execution. This is expected and totally fine.
-          wasInterrupted = true;
-          Logger.log("COMMAND", command.name()  + " (run ID=" + runId + ")" + " was interrupted with Future.cancel() while parked");
-          result = COMPLETED_VALUE;
-        } else {
-          // Command execution raised an error.
-          // Cache it in the errors map for `checkForErrors` to pick up.
-          Logger.log("COMMAND ERROR", e.getMessage());
-          Util.writing(lock, () -> errors.put(command, e));
-          exception = e;
-        }
-        // Rethrow the exception. This will make the future complete with an error state.
-        // If the caller uses `await` on the command or `get` on its associated future,
-        // then this exception will be raised at the call site. Otherwise, it will have
-        // to be picked up by calling `checkForErrors` (presumably in a periodic loop)
-        throw e;
-      } finally {
-        Logger.log("COMMAND", "Execution completed for " + command.name() + " (run ID=" + runId + ")" + ", starting cleanup");
-        Logger.log("COMMAND", "Acquiring lock..." + " (run ID=" + runId + ", owners: " + Util.owners() + ")");
-        // Not using Util.writing() because `wasInterrupted` can't be captured
-        lock.writeLock().lock();
-        Util.push();
-        Logger.log("COMMAND", "Lock acquired" + " (run ID=" + runId + ")");
+      if (!commandStates.containsKey(command)) {
+        // Probably canceled by an owning composition, do not run
+        continue;
+      }
+
+      if (!continuation.isDone()) {
+        currentCommand = command;
+        Logger.log("RUN", "Current command is " + command);
+        Logger.log("RUN", "Mounting continuation for command " + command);
+        mountContinuation(continuation);
         try {
-          if (commandStates.get(command) instanceof CommandState s && s.id == runId) {
-            Logger.log("COMMAND", "Cleaning up after " + command.name() + " (run ID=" + runId + ")");
-            // Clean up if still running. Schedule the default command if we weren't interrupted
-            // Interruption means a new command was explicitly scheduled, so the default command
-            // would not be desired.
-            cleanupAfterCompletion(command, !wasInterrupted);
-          } else {
-            Logger.log("COMMAND", "Command " + command.name() + " (run ID=" + runId + ")" + " was already cleaned up");
-          }
+          Logger.log("RUN", "Running continuation for command " + command + " until it yields");
+          continuation.run();
         } finally {
-          Logger.log("COMMAND", "Releasing lock" + " (run ID=" + runId + ")");
-          try {
-            if (exception != null) {
-              state.completion.completeExceptionally(exception);
-            } else if (result != null) {
-              state.completion.complete(result);
-            } else {
-              // note: result shouldn't be null, but just in case...
-              state.completion.complete(COMPLETED_VALUE);
-            }
-          } finally {
-            Util.pop();
-            lock.writeLock().unlock();
-          }
+          Logger.log("RUN", "Unmounting continuation for command " + command);
+          mountContinuation(null);
         }
+      } else {
+        Logger.log("RUN", "Command " + command + " is done, not running");
       }
-    };
-  }
-
-  /**
-   * Waits for a command to complete. This will block until the command has completed or been
-   * interrupted or cancelled by another command. Does nothing if the given command is not
-   * scheduled.
-   *
-   * @param command the command to wait for.
-   * @throws ExecutionException if the command encountered an error while it was executing
-   */
-  @Reads
-  public void await(AsyncCommand command) throws ExecutionException {
-    Logger.log("AWAIT", "Awaiting " + command.name());
-    var states = Util.reading(lock, () -> commandStates.get(command));
-
-    if (states == null) {
-      // not currently running, nothing to await
-      Logger.log("AWAIT", "Command " + command.name() + " is not currently running, nothing to await");
-      return;
     }
 
-    try {
-      Logger.log("AWAIT", "Parking until " + command.name() + " (run ID=" + states.id + ") completes or is canceled...");
-      long start = System.nanoTime();
-      states.completion.get();
-      long end = System.nanoTime();
-      Logger.log("AWAIT", "Command " + command.name() + " (run ID=" + states.id + ") exited after waiting " + (end - start) / 1e3 + " µs");
-    } catch (InterruptedException e) {
-      // Interrupted while waiting, reset the interrupt flag but do not raise
-      Logger.log("AWAIT", "Interrupted while awaiting " + command.name());
-      Thread.currentThread().interrupt();
-    } catch (ExecutionException e) {
-      // Swallow execution exceptions caused by interrupts
-      var interuptionCause = e.getCause();
-      while (interuptionCause != null && !(interuptionCause instanceof InterruptedException)) {
-        interuptionCause = interuptionCause.getCause();
-      }
-      if (interuptionCause == null) {
-        Logger.log("AWAIT", "Command " + command.name() + " errored while awaiting its completion: " + e.getMessage());
-        throw e;
-      }
-    } catch (CancellationException e) {
-      // Command was cancelled, nothing wrong here
-      Logger.log("AWAIT", "Command " + command.name() + " (run ID=" + states.id + ") was cancelled while awaiting its completion");
-    }
-  }
+    currentCommand = null;
 
-  @Writes
-  private CommandState fireScheduleEvent(AsyncCommand command) {
-    return Util.writing(
-        lock,
-        () -> {
-          // Sanity check to make sure we're not overwriting state for the scheduled command, if it
-          // was already running when rescheduled. It should have been cancelled above.
-          var existingStates = commandStates.get(command);
-          if (existingStates != null) {
-            throw new IllegalStateException("Command state was not cleared!");
-          }
-
-          // schedule the command to run on a virtual thread, automatically scheduling the default
-          // commands for all its required resources when it completes
-          var scheduled = new CompletableFuture<Boolean>();
-          var completion = new CompletableFuture<>();
-          var states = new CommandState(command, scheduled, completion);
-          Callable<?> callback = createCommandExecutorCallback(command, states);
-          states.exec = service.submit(callback);
-          commandStates.put(command, states);
-          Logger.log("SCHEDULE", "Created async future for command " + command.name() + " (assigned run ID=" + states.id + ")");
-          Logger.log("SCHEDULE", "All command states: " + commandStates);
-          return states;
-        });
-  }
+    // Remove completed commands
+    Logger.log("RUN", "Cleaning up after completed commands");
+    commandStates.entrySet().removeIf(e -> e.getValue().continuation.isDone());
 
-  @Writes
-  private CommandState fireCancelEvent(AsyncCommand command) {
-    if (command == null) {
-      // Nothing to do
-      return null;
+    // Schedule default commands for any resource currently without a command
+    for (var resource : defaultCommands.keySet()) {
+      Logger.log("RUN", "Checking if default command needs to run for " + resource + "...");
+      var owner = commandStates.keySet().stream().filter(c -> c.requires(resource)).findAny();
+      if (owner.isPresent()) {
+        Logger.log("RUN", "No, already running " + owner.get());
+      } else {
+        Logger.log("RUN", "Yes, scheduling");
+        scheduleDefault(resource);
+      }
     }
 
-    Logger.log("CANCEL", "Cancelling command " + command.name());
-    return Util.writing(
-        lock,
-        () -> {
-          var state = commandStates.get(command);
-          if (state == null) {
-            // Not running, nothing to cancel
-            Logger.log("CANCEL", "Command " + command.name() + " is not running. Nothing to cancel");
-            return null;
-          }
-
-          Logger.log("CANCEL", "Triggering interrupt for command " + command.name() + " (run ID=" + state.id + ")");
-          state.exec.cancel(true);
-          return state;
-        });
-  }
-
-  public void cancel(AsyncCommand command) {
-    cancelAndWait(command, true);
+    Logger.log("RUN", "Ending run #" + runNum);
   }
 
-  /**
-   * Cancels a running command and schedules the default commands for all of its required resources.
-   * Has no effect if the given command is not currently running.
-   *
-   * <p>This method will wait until the command has fully exited before returning. A timeout for the
-   * wait can be configured by setting {@link #cancelTimeout}.
-   *
-   * @param command the command to cancel
-   */
-  @Writes
-  public void cancelAndWait(AsyncCommand command, boolean thenRunDefault) {
-    if (command == null) {
-      // Nothing to do
-      return;
-    }
-
-    var states = fireCancelEvent(command);
-    if (states == null) {
-      return;
-    }
-
-    long runId = states.id;
-
-    try {
-      // Wait for the command to exit. A cancellation request will interrupt the vthread and
-      // immediately return, but the command could continue running until it reaches a point where it
-      // calls an interruptible function like Thread.sleep.
-
-      Logger.log("CANCEL", "Waiting for command " + command.name() + " to exit (run ID=" + runId + ")");
-      states.completion.get((long) cancelTimeout.in(Nanoseconds), TimeUnit.NANOSECONDS);
-      Logger.log("CANCEL", "Command " + command.name() + " (run ID=" + runId + ") exited within " + cancelTimeout.in(Microseconds) + " µs of the cancellation request");
-
-      // Clean up only after the command has completed
-      cleanupAfterCompletion(command, thenRunDefault);
-    } catch (TimeoutException e) {
-      String message = "Command " + command.name() + " (run ID=" + runId + ") did not stop within " + cancelTimeout.in(Microseconds) + " µs of the cancellation request!";
-      Logger.log("CANCEL", message);
-      Logger.log("CANCEL", "Current lock owner: " + Util.getCurrentOwnerName());
+  private Continuation buildContinuation(AsyncCommand command) {
+    return new Continuation(scope, () -> {
       try {
-        Files.writeString(Path.of("thread-dump.txt"), Logger.formattedLogTable());
-      } catch (Exception ignore) {}
-      throw new IllegalStateException(message);
-    } catch (InterruptedException e) {
-      // Why would the carrier thread be interrupted?
-      throw new RuntimeException("Carrier thread interrupted while waiting for command cancellation", e);
-    } catch (ExecutionException e) {
-      // I think we'd want to rethrow the original exception instead of rewrapping it...
-      throw new RuntimeException(e);
-    }
-    Logger.log("CANCEL", "Cancelled command " + command.name() + " (run ID=" + runId + ")");
+        command.run();
+        Logger.log("CONTINUATION", "Command " + command + " completed naturally");
+      } catch (Exception e) {
+        throw new CommandExecutionException(command, e);
+      }
+    });
   }
 
-  /**
-   * Cleans up state after a command completes or is cancelled. This method is not inherently
-   * thread-safe and must be wrapped in calls to the write lock.
-   *
-   * @param command the command to clean up after
-   */
-  @NotLocking
-  private void cleanupAfterCompletion(AsyncCommand command, boolean thenRunDefault) {
-    // TODO: This may be buggy at the boundary where a command completes and is immediately rescheduled
-    var states = commandStates.get(command);
-    if (states == null) {
-      Logger.log("CLEANUP", "Cannot clean up for a command that isn't running! Requested command " + command.name() + " has no associated states");
-      return;
-    }
-
-    long runId = states.id;
-    Logger.log("CLEANUP", "Removing future states for " + command.name() + " (run ID=" + runId + ")");
-    commandStates.remove(command);
-
-    // Clear current thread owner
-    if (commandOnCurrentThread.get().command == command) {
-      Logger.log("CLEANUP", "Clearing threadlocal owner " + command.name() + " (run ID=" + runId + ")");
-      commandOnCurrentThread.remove();
-    }
-
-    for (var resource : command.requirements()) {
-      // If the currently running command for this resource is the one we just
-      // cancelled, we can schedule its default command
-      if (runningCommands.remove(resource, command) && thenRunDefault) {
-        Logger.log("CLEANUP", "Scheduling default command for " + resource.getName() + " after run " + runId);
-        scheduleDefault(resource);
+  private void mountContinuation(Continuation continuation) {
+    try {
+      if (continuation == null) {
+        java_lang_thread_setContinuation.invoke(Thread.currentThread(), null);
+      } else {
+        java_lang_thread_setContinuation.invoke(Thread.currentThread(), continuation.continuation);
       }
+    } catch (Throwable t) {
+      // Anything thrown internally by Thread.setContinuation.
+      // It only assigns to a field, no way to throw
+      // However, if the invocation fails for some reason, we'll end up with an
+      // IllegalStateException when attempting to run an unmounted continuation
     }
-    Logger.log("CLEANUP", "Completed cleanup for " + command.name() + " (run ID=" + runId + ")");
   }
 
   /**
@@ -616,56 +263,20 @@ private void cleanupAfterCompletion(AsyncCommand command, boolean thenRunDefault
    * @param command the command to check
    * @return true if the command is running, false if not
    */
-  @Reads
   public boolean isRunning(AsyncCommand command) {
-    return Util.reading(lock, () -> commandStates.containsKey(command));
+    return commandStates.containsKey(command);
   }
 
-  /**
-   * @return
-   */
-  @Reads
-  public Map<HardwareResource, AsyncCommand> getRunningCommands() {
-    return Util.reading(lock, () -> Map.copyOf(runningCommands));
+  public Set<AsyncCommand> getRunningCommands() {
+    return Collections.unmodifiableSet(commandStates.keySet());
   }
 
   /**
    * Cancels all currently running commands, then starts the default commands for any resources
    * that had canceled commands. A default command that is currently running will not be canceled.
    */
-  @Writes
   public void cancelAll() {
-    Logger.log("CANCELALL", "Cancelling all commands");
-    var canceledStates = Util.writing(
-        lock,
-        () -> {
-          var states = new ArrayList<CommandState>();
-          for (AsyncCommand command : commandStates.keySet()) {
-            if (defaultCommands.containsValue(command)) {
-              // Don't bother cancelling a default command.
-              // It'd be reinitialized immediately afterward
-              continue;
-            }
-            states.add(fireCancelEvent(command));
-          }
-          return states;
-        });
-    Logger.log("CANCELALL", "All interrupts fired, waiting for commands to exit...");
-    awaitBulkCancellation(canceledStates);
-    Logger.log("CANCELALL", "All commands successfully exited, starting default commands...");
-    var newStates = Util.writing(lock, () -> {
-      return
-          defaultCommands
-              .values()
-              .stream()
-              .filter(c -> !isRunning(c)) // Don't schedule a default command that's already running
-              .filter(this::isSchedulable)
-              .map(this::fireScheduleEvent)
-              .toList();
-    });
-    // WAIT OUTSIDE THE LOCK
-    awaitBulkSchedulation(newStates);
-    Logger.log("CANCELALL", "Complete");
+    commandStates.clear();
   }
 
   /**
@@ -674,7 +285,6 @@ public void cancelAll() {
    *
    * @param resource the resource to schedule the default command for
    */
-  @Writes
   public void scheduleDefault(HardwareResource resource) {
     var defaultCommand = defaultCommands.computeIfAbsent(resource, IdleCommand::new);
     schedule(defaultCommand);
@@ -687,126 +297,15 @@ public void scheduleDefault(HardwareResource resource) {
    * @return the running command using a particular resource, or null if no command is currently
    * using it
    */
-  @Reads
   public AsyncCommand getCommandUsing(HardwareResource resource) {
-    return Util.reading(lock, () -> runningCommands.get(resource));
-  }
-
-  private static final ThreadLocal<CommandState> commandOnCurrentThread = new ThreadLocal<>();
-
-  /**
-   * Pauses the current command for 20 milliseconds. If a higher priority command on
-   * any of the current command's required resources is scheduled while paused, the higher
-   * priority command will interrupt the command while it is paused.
-   *
-   * @throws InterruptedException if the current command was canceled or interrupted by a higher
-   *   priority command
-   */
-  @Reads
-  public void pauseCurrentCommand() throws InterruptedException {
-    pauseCurrentCommand(DEFAULT_UPDATE_PERIOD);
+    return commandStates.keySet().stream().filter(c -> c.requires(resource)).findFirst().orElse(null);
   }
 
-  /**
-   * Pauses the current command for the specified period of time.  If a higher priority command on
-   * any of the current command's required resources is scheduled while paused, the higher
-   * priority command will interrupt the command while it is paused.
-   *
-   * @throws InterruptedException if the current command was canceled or interrupted by a higher
-   *   priority command
-   */
-  @Reads
-  public void pauseCurrentCommand(Measure<Time> time) throws InterruptedException {
-    var states = commandOnCurrentThread.get();
-    if (states == null) {
-      throw new IllegalStateException(
-          "pauseCurrentCommand() may only be called by a running command!");
-    }
-    var command = states.command;
-
-    Logger.log("PAUSE", "Pausing " + command.name());
-
-//    var states = Util.reading(lock, () -> {
-//      Logger.log("PAUSE", "All states: " + commandStates);
-//      return commandStates.get(command);
-//    });
-//
-//    if (states == null) {
-//      System.err.println(Logger.formattedLogTable());
-//      throw new IllegalStateException("Command " + command.name() + " is not tracked!");
-//    }
-
-    if (Thread.currentThread().isInterrupted()) {
-      // Thread interrupt flag was set prior to entering pause
-      // This can happen if command code uses Timer.delay or something similar where an interrupted
-      // exception is caught and the interrupt flag is set
-      Logger.log("PAUSE", "Command " + command.name() + " was interrupted without raising an exception");
-      throw new InterruptedException();
-    }
-
-    long ms = (long) time.in(Milliseconds);
-    int ns = (int) (time.in(Nanoseconds) % 1e6);
-
-    long start = WPIUtilJNI.now();
-    Logger.log("PAUSE", "Parking for " + time.in(Microseconds) + " µs...");
-    Thread.sleep(ms, ns);
-    long end = WPIUtilJNI.now();
-    Logger.log("PAUSE", "Woke up after " + (end - start) + " µs waiting (target=" + time.in(Microseconds) + " µs)");
-
-    if (Thread.currentThread().isInterrupted()) {
-      // Interrupted while paused, but without an interrupted exception being thrown?
-      Logger.log("PAUSE", "Command " + command.name() + " was interrupted while parked without raising an exception!");
-      System.err.println(Logger.formattedLogTable());
-      throw new IllegalStateException();
-    }
-
-    // TODO: How can a command be removed from the futures list without being interrupted?
-    var statesAfterPause = Util.reading(lock, () -> commandStates.get(command));
-    if (statesAfterPause != states) {
-      String message = "Command " + command.name() + " (run ID=" + states.id + ")" + " was removed from the scheduler while paused without being interrupted!";
-      if (statesAfterPause != null) {
-        message += " (current run ID=" + statesAfterPause.id + " did not match!)";
-      }
-      throw new IllegalStateException(message);
-    }
+  public boolean yield() {
+    return Continuation.yield(scope);
   }
 
-  private static final AtomicLong invocationId = new AtomicLong(0);
-
-  static final class CommandState {
-    /**
-     * A unique ID that identifies the command state. Every run of a command gets a new state,
-     * even for the same command object. The ID helps to distinguish the separate runs.
-     */
-    final long id = invocationId.incrementAndGet();
-
-    final AsyncCommand command;
-
-    // assigned after construction
-    Future<?> exec;
-    final CompletableFuture<Boolean> schedule;
-    final CompletableFuture<Object> completion;
-
-    CommandState(
-        AsyncCommand command,
-        CompletableFuture<Boolean> schedule,
-        CompletableFuture<Object> completion) {
-      this.command = command;
-      this.schedule = schedule;
-      this.completion = completion;
-    }
-
-    @Override
-    public String toString() {
-      return "CommandState(" +
-                 "id=" + id +
-                 ", command=" + command.name() +
-                 ", exec=" + exec.state() +
-                 ", schedule=" + schedule.state() +
-                 ", completion=" + completion.state() +
-                 ')';
-    }
-  }
+  record CommandState(AsyncCommand command, Continuation continuation) { }
 
   public EventLoop getDefaultButtonLoop() {
     return eventLoop;
diff --git a/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj3/command/async/Continuation.java b/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj3/command/async/Continuation.java
new file mode 100644
index 00000000000..468c94781bc
--- /dev/null
+++ b/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj3/command/async/Continuation.java
@@ -0,0 +1,109 @@
+package edu.wpi.first.wpilibj3.command.async;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+
+/**
+ * A wrapper around the JDK internal Continuation class.
+ */
+public final class Continuation {
+  // The underlying jdk.internal.vm.Continuation object
+  final Object continuation;
+
+  static final Class<?> jdk_internal_vm_Continuation;
+  private static final MethodHandle CONSTRUCTOR;
+  private static final MethodHandle YIELD;
+  private static final MethodHandle RUN;
+  private static final MethodHandle IS_DONE;
+
+  static {
+    try {
+      jdk_internal_vm_Continuation = Class.forName("jdk.internal.vm.Continuation");
+
+      var lookup = MethodHandles.privateLookupIn(jdk_internal_vm_Continuation, MethodHandles.lookup());
+
+      CONSTRUCTOR = lookup.findConstructor(
+          jdk_internal_vm_Continuation,
+          MethodType.methodType(void.class, ContinuationScope.jdk_internal_vm_ContinuationScope, Runnable.class)
+      );
+
+      YIELD = lookup.findStatic(
+          jdk_internal_vm_Continuation,
+          "yield",
+          MethodType.methodType(boolean.class, ContinuationScope.jdk_internal_vm_ContinuationScope)
+      );
+
+      RUN = lookup.findVirtual(
+          jdk_internal_vm_Continuation,
+          "run",
+          MethodType.methodType(void.class)
+      );
+
+      IS_DONE = lookup.findVirtual(
+          jdk_internal_vm_Continuation,
+          "isDone",
+          MethodType.methodType(boolean.class)
+      );
+    } catch (Throwable t) {
+      throw new ExceptionInInitializerError(t);
+    }
+  }
+
+  /**
+   * Constructs a continuation.
+   *
+   * @param scope the continuation's scope, used in yield
+   * @param target the continuation's body
+   */
+  public Continuation(ContinuationScope scope, Runnable target) {
+    try {
+      this.continuation = CONSTRUCTOR.invoke(scope.continuationScope, target);
+    } catch (Throwable t) {
+      throw new RuntimeException(t);
+    }
+  }
+
+  /**
+   * Suspends the current continuations up to the given scope.
+   *
+   * @param scope The {@link ContinuationScope} to suspend
+   * @return {@code true} for success; {@code false} for failure
+   * @throws IllegalStateException if not currently in the given {@code scope},
+   */
+  public static boolean yield(ContinuationScope scope) {
+    try {
+      return (boolean) YIELD.invoke(scope.continuationScope);
+    } catch (Throwable t) {
+      throw new RuntimeException(t);
+    }
+  }
+
+  /**
+   * Mounts and runs the continuation body. If suspended, continues it from the last suspend point.
+   */
+  public void run() {
+    try {
+      RUN.invoke(continuation);
+    } catch (Throwable t) {
+      throw new RuntimeException(t);
+    }
+  }
+
+  /**
+   * Tests whether this continuation is completed
+   * @return whether this continuation is completed
+   */
+  public boolean isDone() {
+    try {
+      return (boolean) IS_DONE.invoke(continuation);
+    } catch (Throwable t) {
+      throw new RuntimeException(t);
+    }
+  }
+
+  @Override
+  public String toString() {
+    return continuation.toString();
+  }
+}
\ No newline at end of file
diff --git a/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj3/command/async/ContinuationScope.java b/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj3/command/async/ContinuationScope.java
new file mode 100644
index 00000000000..f2cf40de78b
--- /dev/null
+++ b/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj3/command/async/ContinuationScope.java
@@ -0,0 +1,46 @@
+package edu.wpi.first.wpilibj3.command.async;
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+import java.util.Objects;
+
+public final class ContinuationScope {
+  // The underlying jdk.internal.vm.ContinuationScope object
+  final Object continuationScope;
+
+  static final Class<?> jdk_internal_vm_ContinuationScope;
+  private static final MethodHandle CONSTRUCTOR;
+
+  static {
+    try {
+      jdk_internal_vm_ContinuationScope = Class.forName("jdk.internal.vm.ContinuationScope");
+
+      var lookup = MethodHandles.privateLookupIn(
+          jdk_internal_vm_ContinuationScope,
+          MethodHandles.lookup()
+      );
+
+      CONSTRUCTOR = lookup.findConstructor(
+          jdk_internal_vm_ContinuationScope,
+          MethodType.methodType(void.class, String.class)
+      );
+    } catch (Throwable t) {
+      throw new ExceptionInInitializerError(t);
+    }
+  }
+
+  public ContinuationScope(String name) {
+    Objects.requireNonNull(name);
+    try {
+      this.continuationScope = CONSTRUCTOR.invoke(name);
+    } catch (Throwable e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  @Override
+  public String toString() {
+    return continuationScope.toString();
+  }
+}
\ No newline at end of file
diff --git a/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj3/command/async/HardwareResource.java b/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj3/command/async/HardwareResource.java
index fbec904cbc7..624b1b66860 100644
--- a/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj3/command/async/HardwareResource.java
+++ b/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj3/command/async/HardwareResource.java
@@ -56,7 +56,7 @@ public AsyncCommand idle() {
   }
 
   public AsyncCommand idle(Measure<Time> duration) {
-    return new IdleCommand(this, duration);
+    return idle().withTimeout(duration);
   }
 
   public AsyncCommandBuilder runSequence(AsyncCommand... commands) {
diff --git a/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj3/command/async/IdleCommand.java b/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj3/command/async/IdleCommand.java
index 768db6cff75..c72e900dacb 100644
--- a/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj3/command/async/IdleCommand.java
+++ b/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj3/command/async/IdleCommand.java
@@ -12,14 +12,12 @@
  *
  * @param resource the resource to idle.
  */
-public record IdleCommand(HardwareResource resource, Measure<Time> duration) implements AsyncCommand {
-  public IdleCommand(HardwareResource resource) {
-    this(resource, Milliseconds.of(Long.MAX_VALUE));
-  }
-
+public record IdleCommand(HardwareResource resource) implements AsyncCommand {
   @Override
   public void run() throws InterruptedException {
-    AsyncCommand.pause(duration);
+    while (true) {
+      AsyncScheduler.getInstance().yield();
+    }
   }
 
   @Override
@@ -42,14 +40,4 @@ public int priority() {
   public String toString() {
     return name();
   }
-
-  @Override
-  public boolean equals(Object obj) {
-    return obj == this;
-  }
-
-  @Override
-  public int hashCode() {
-    return Objects.hash(resource, duration);
-  }
 }
diff --git a/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj3/command/async/Logger.java b/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj3/command/async/Logger.java
index c5051452aba..0d03eb67810 100644
--- a/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj3/command/async/Logger.java
+++ b/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj3/command/async/Logger.java
@@ -9,8 +9,13 @@ public class Logger {
   private static final List<LogRecord> records = new ArrayList<>();
 
   public static synchronized void log(String context, String message) {
+    if (true) {
+      // Remove this for live debugging.
+      // The logger can use a lot of memory to store records so it is disabled by default
+      return;
+    }
     var now = WPIUtilJNI.now() / 1e6;
-    LogRecord record = new LogRecord(now, Thread.currentThread().getName(), context, message);
+    LogRecord record = new LogRecord(now, "Async Runner", context, message);
 
     records.add(record);
   }
@@ -94,7 +99,7 @@ public static String formattedLogTable() {
       for (int thread = 0; thread < threadCount; thread++) {
         table.append('|');
         if (thread == threadIndex) {
-          table.append(("%" + threadColumnWidth + "s ").formatted(record.printedMessage()));
+          table.append((" %-" + threadColumnWidth + "s").formatted(record.printedMessage()));
         } else {
           table.append(" ".repeat(threadColumnWidth + 1));
         }
diff --git a/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj3/command/async/ParallelGroup.java b/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj3/command/async/ParallelGroup.java
new file mode 100644
index 00000000000..5585ad383c5
--- /dev/null
+++ b/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj3/command/async/ParallelGroup.java
@@ -0,0 +1,173 @@
+package edu.wpi.first.wpilibj3.command.async;
+
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+
+public class ParallelGroup implements AsyncCommand {
+  private final Collection<AsyncCommand> commands = new LinkedHashSet<>();
+  private final Collection<AsyncCommand> requiredCommands = new HashSet<>();
+  private final Set<HardwareResource> requirements = new HashSet<>();
+  private final AsyncScheduler scheduler;
+  private final String name;
+  private final int priority;
+  private RobotDisabledBehavior disabledBehavior;
+
+  public ParallelGroup(
+      String name,
+      AsyncScheduler scheduler,
+      Collection<AsyncCommand> allCommands,
+      Collection<AsyncCommand> requiredCommands) {
+    if (!allCommands.containsAll(requiredCommands)) {
+      throw new IllegalArgumentException(
+          "Required commands must also be composed");
+    }
+
+    for (AsyncCommand c1 : allCommands) {
+      for (AsyncCommand c2 : allCommands) {
+        if (c1 == c2) {
+          // Commands can't conflict with themselves
+          continue;
+        }
+        if (c1.conflictsWith(c2)) {
+          throw new IllegalArgumentException(
+              "Commands in a parallel composition cannot require the same resources. "
+                  + c1
+                  + " and "
+                  + c2
+                  + " conflict.");
+        }
+      }
+    }
+
+    this.name = name;
+    this.scheduler = scheduler;
+    this.commands.addAll(allCommands);
+    this.requiredCommands.addAll(requiredCommands);
+
+    for (var command : allCommands) {
+      requirements.addAll(command.requirements());
+    }
+
+    this.priority =
+        allCommands
+            .stream()
+            .mapToInt(AsyncCommand::priority)
+            .max()
+            .orElse(AsyncCommand.DEFAULT_PRIORITY);
+
+    this.disabledBehavior = RobotDisabledBehavior.RunWhileDisabled;
+    for (AsyncCommand command : allCommands) {
+      if (command.robotDisabledBehavior() == RobotDisabledBehavior.CancelWhileDisabled) {
+        this.disabledBehavior = RobotDisabledBehavior.CancelWhileDisabled;
+        break;
+      }
+    }
+  }
+
+  /**
+   * Creates a parallel group that runs all the given commands until any of them finish.
+   * @param name the name of the group
+   * @param commands the commands to run in parallel
+   * @return the group
+   */
+  public static ParallelGroup race(String name, AsyncCommand... commands) {
+    return new ParallelGroup(
+        name,
+        AsyncScheduler.getInstance(),
+        List.of(commands),
+        Set.of()
+    );
+  }
+
+  /**
+   * Creates a parallel group that runs all the given commands until they all finish. If a command
+   * finishes early, its required resources will be idle (uncommanded) until the group completes.
+   *
+   * @param name the name of the group
+   * @param commands the commands to run in parallel
+   * @return the group
+   */
+  public static ParallelGroup all(String name, AsyncCommand... commands) {
+    return new ParallelGroup(
+        name,
+        AsyncScheduler.getInstance(),
+        List.of(commands),
+        List.of(commands)
+    );
+  }
+
+  @Override
+  public void run() throws Exception {
+    Logger.log(name, "Starting");
+    for (AsyncCommand command : commands) {
+      Logger.log(name, "Scheduling child command " + command);
+      scheduler.scheduleComposed(command, this);
+    }
+    scheduler.yield();
+
+    while (true) {
+      Logger.log(name, "Checking for group completion");
+      if (requiredCommands.isEmpty()) {
+        // No command is required, so we run until at least one command completes
+        Logger.log(name, "Checking if any command has completed yet");
+
+        boolean completed = false;
+        for (AsyncCommand c : commands) {
+          Logger.log(name, "Child command " + c + " running: " + scheduler.isRunning(c));
+          if (!scheduler.isRunning(c)) {
+            Logger.log(name, "Command " + c + " completed!");
+            completed = true;
+            break;
+          }
+        }
+        if (completed) {
+          Logger.log(name, "Completed");
+          break;
+        }
+      } else {
+        // We run all commands until every required command has completed
+        Logger.log(name, "Checking if all required commands have completed yet");
+        if (requiredCommands.stream().noneMatch(scheduler::isRunning)) {
+          Logger.log(name, "Completed");
+          break;
+        }
+      }
+
+      Logger.log(name, "Yielding to the scheduler");
+      scheduler.yield();
+    }
+
+    Logger.log(name, "Cancelling composed commands after completion");
+    for (AsyncCommand command : commands) {
+      scheduler.cancel(command);
+    }
+  }
+
+  @Override
+  public String name() {
+    return name;
+  }
+
+  @Override
+  public Set<HardwareResource> requirements() {
+    return requirements;
+  }
+
+  @Override
+  public int priority() {
+    return priority;
+  }
+
+  @Override
+  public RobotDisabledBehavior robotDisabledBehavior() {
+    return disabledBehavior;
+  }
+
+  @Override
+  public String toString() {
+    return "ParallelGroup[name=" + name + "]";
+  }
+}
diff --git a/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj3/command/async/WaitCommand.java b/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj3/command/async/WaitCommand.java
new file mode 100644
index 00000000000..27202a8e914
--- /dev/null
+++ b/wpilibNewCommands/src/main/java/edu/wpi/first/wpilibj3/command/async/WaitCommand.java
@@ -0,0 +1,38 @@
+package edu.wpi.first.wpilibj3.command.async;
+
+import static edu.wpi.first.units.Units.Seconds;
+
+import edu.wpi.first.units.Measure;
+import edu.wpi.first.units.Time;
+import edu.wpi.first.wpilibj.Timer;
+import java.util.Set;
+
+/**
+ * A command with no requirements that merely waits for a specified duration of time to elapse.
+ */
+public class WaitCommand implements AsyncCommand {
+  private final Measure<Time> duration;
+
+  public WaitCommand(Measure<Time> duration) {
+    this.duration = duration;
+  }
+
+  @Override
+  public void run() throws Exception {
+    var timer = new Timer();
+    timer.start();
+    while (!timer.hasElapsed(duration.in(Seconds))) {
+      AsyncCommand.yield();
+    }
+  }
+
+  @Override
+  public String name() {
+    return "Wait " + duration.in(Seconds) + " Seconds";
+  }
+
+  @Override
+  public Set<HardwareResource> requirements() {
+    return Set.of();
+  }
+}
diff --git a/wpilibNewCommands/src/test/java/edu/wpi/first/wpilibj3/command/async/AsyncSchedulerTest.java b/wpilibNewCommands/src/test/java/edu/wpi/first/wpilibj3/command/async/AsyncSchedulerTest.java
index 8ea6c5d5c58..95bb6b11530 100644
--- a/wpilibNewCommands/src/test/java/edu/wpi/first/wpilibj3/command/async/AsyncSchedulerTest.java
+++ b/wpilibNewCommands/src/test/java/edu/wpi/first/wpilibj3/command/async/AsyncSchedulerTest.java
@@ -1,10 +1,7 @@
 package edu.wpi.first.wpilibj3.command.async;
 
-import static edu.wpi.first.units.Units.Milliseconds;
-import static edu.wpi.first.units.Units.Seconds;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.Assertions.fail;
 
@@ -14,7 +11,7 @@
 import java.util.concurrent.atomic.AtomicInteger;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.RepeatedTest;
+import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.Timeout;
 
 @Timeout(5)
@@ -25,11 +22,11 @@ class AsyncSchedulerTest {
   void setup() {
     Logger.clear();
 
-    // Initialize with high default timeouts so random jitter doesn't make tests flake out
-    scheduler = new AsyncScheduler(
-        Seconds.one(), // event loop period
-        Milliseconds.of(25), // cancel timeout
-        Milliseconds.of(25)); // schedule timeout
+    // Any command that calls AsyncCommand.park() or AsyncCommand.yield() uses the default
+    // scheduler instance. Notably, this includes commands with timeouts, wait commands, and
+    // the default idle commands
+    scheduler = new AsyncScheduler();
+    AsyncScheduler.setDefaultScheduler(scheduler);
   }
 
   @AfterEach
@@ -38,20 +35,23 @@ void printLogs() {
     Logger.clear();
   }
 
-  @RepeatedTest(value = 1000, failureThreshold = 1)
+  @Test
   void basic() throws Exception {
     var enabled = new AtomicBoolean(false);
     var ran = new AtomicBoolean(false);
     var command = AsyncCommand.noHardware(() -> {
-      do {} while (!enabled.get());
+      do {
+        scheduler.yield();
+      } while (!enabled.get());
       ran.set(true);
     }).named("Basic Command");
 
     scheduler.schedule(command);
+    scheduler.run();
     assertTrue(scheduler.isRunning(command), "Command should be running after being scheduled");
 
     enabled.set(true);
-    scheduler.await(command);
+    scheduler.run();
     if (scheduler.isRunning(command)) {
       System.err.println(Logger.formattedLogTable());
       fail("Command should no longer be running after awaiting its completion");
@@ -60,23 +60,24 @@ void basic() throws Exception {
     assertTrue(ran.get());
   }
 
-  @RepeatedTest(value = 100, failureThreshold = 1)
+  @Test
   void higherPriorityCancels() {
     var subsystem = new HardwareResource("Subsystem", scheduler);
 
     var lower = new PriorityCommand(-1000, subsystem);
     var higher = new PriorityCommand(+1000, subsystem);
 
-    scheduler.scheduleTimeout = Milliseconds.of(25);
     scheduler.schedule(lower);
+    scheduler.run();
     assertTrue(scheduler.isRunning(lower));
 
     scheduler.schedule(higher);
+    scheduler.run();
     assertTrue(scheduler.isRunning(higher));
     assertFalse(scheduler.isRunning(lower));
   }
 
-  @RepeatedTest(value = 100, failureThreshold = 1)
+  @Test
   void lowerPriorityDoesNotCancel() {
     var subsystem = new HardwareResource("Subsystem", scheduler);
 
@@ -84,9 +85,11 @@ void lowerPriorityDoesNotCancel() {
     var higher = new PriorityCommand(+1000, subsystem);
 
     scheduler.schedule(higher);
+    scheduler.run();
     assertTrue(scheduler.isRunning(higher));
 
     scheduler.schedule(lower);
+    scheduler.run();
     if (!scheduler.isRunning(higher)) {
       System.err.println(Logger.formattedLogTable());
       fail("Higher priority command should still be running");
@@ -97,7 +100,7 @@ void lowerPriorityDoesNotCancel() {
     }
   }
 
-  @RepeatedTest(value = 100, failureThreshold = 1)
+  @Test
   void samePriorityCancels() {
     var subsystem = new HardwareResource("Subsystem", scheduler);
 
@@ -105,15 +108,17 @@ void samePriorityCancels() {
     var second = new PriorityCommand(512, subsystem);
 
     scheduler.schedule(first);
+    scheduler.run();
     assertTrue(scheduler.isRunning(first));
 
     scheduler.schedule(second);
+    scheduler.run();
     assertTrue(scheduler.isRunning(second), "New command should be running");
     assertFalse(scheduler.isRunning(first), "Old command should be canceled");
   }
 
-  @RepeatedTest(value = 100, failureThreshold = 1)
-  void atomicity() throws Exception {
+  @Test
+  void atomicity() {
     var resource =
         new HardwareResource("X", scheduler) {
           int x = 0;
@@ -132,7 +137,7 @@ void atomicity() throws Exception {
           AsyncCommand.noHardware(
                   () -> {
                     for (int i = 0; i < iterations; i++) {
-                      scheduler.pauseCurrentCommand(Milliseconds.one());
+                      scheduler.yield();
                       resource.x++;
                     }
                   })
@@ -142,14 +147,15 @@ void atomicity() throws Exception {
       commands.add(command);
     }
 
-    for (var command : commands) {
-      scheduler.await(command);
+    for (int i = 0; i < iterations; i++) {
+      scheduler.run();
     }
+    scheduler.run();
 
     assertEquals(numCommands * iterations, resource.x);
   }
 
-  @RepeatedTest(value = 100, failureThreshold = 1)
+  @Test
   void errorDetection() throws Exception {
     var resource = new HardwareResource("X", scheduler);
 
@@ -157,21 +163,14 @@ void errorDetection() throws Exception {
         resource
             .run(
                 () -> {
-                  Thread.sleep(10);
                   throw new RuntimeException("The exception");
                 })
             .named("Bad Behavior");
 
     scheduler.schedule(command);
 
-    // wait for the command to complete, but not using await, since that would throw an error
-    // immediately - and we want to confirm that checkForErrors will correctly capture and throw
-    while (scheduler.isRunning(command)) {
-      Thread.sleep(1);
-    }
-
     try {
-      scheduler.checkForErrors();
+      scheduler.run();
       fail("An exception should have been thrown");
     } catch (CommandExecutionException e) {
       if (e.getCommand() != command) {
@@ -186,11 +185,13 @@ void errorDetection() throws Exception {
             "Expected cause to be a RuntimeException with message 'The exception', but was "
                 + cause);
       }
+    } catch (Throwable t) {
+      fail("Expected a CommandExecutionException to be thrown, but got " + t);
     }
   }
 
-  @RepeatedTest(value = 100, failureThreshold = 1)
-  void runResource() throws Exception {
+  @Test
+  void runResource() {
     var example =
         new HardwareResource("Counting", scheduler) {
           int x = 0;
@@ -202,76 +203,79 @@ void runResource() throws Exception {
                 () -> {
                   example.x = 0;
                   for (int i = 0; i < 10; i++) {
-                    scheduler.pauseCurrentCommand(Milliseconds.one());
+                    scheduler.yield();
                     example.x++;
                   }
                 })
             .named("Count To Ten");
 
     scheduler.schedule(countToTen);
-    scheduler.await(countToTen);
+    for (int i = 0; i < 10; i++) {
+      scheduler.run();
+    }
+    scheduler.run();
 
     assertEquals(10, example.x);
   }
 
-  @RepeatedTest(value = 100, failureThreshold = 1)
+  @Test
   void cancelOnInterruptDoesNotResume() throws Exception {
     var count = new AtomicInteger(0);
 
     var resource = new HardwareResource("Resource", scheduler);
 
     var interrupter = AsyncCommand.requiring(resource).executing(() -> {
-      Thread.sleep(50);
     }).withPriority(2).named("Interrupter");
 
     var canceledCommand = AsyncCommand.requiring(resource).executing(() -> {
       count.set(1);
-      scheduler.pauseCurrentCommand();
+      scheduler.yield();
       count.set(2);
     }).withPriority(1).named("Cancel By Default");
 
     scheduler.schedule(canceledCommand);
-    Thread.sleep(5); // wait for command to start up and hit the pause
+    scheduler.run();
 
     scheduler.schedule(interrupter);
-    scheduler.await(canceledCommand);
-    assertEquals(1, count.get()); // the second set should not have run
+    scheduler.run();
+    assertEquals(1, count.get()); // the second "set" call should not have run
   }
 
-  @RepeatedTest(value = 100, failureThreshold = 1)
-  void pauseOutsideCommand() {
-    assertThrows(IllegalStateException.class, scheduler::pauseCurrentCommand);
-  }
-
-  @RepeatedTest(value = 10, failureThreshold = 1)
+  @Test
   void scheduleOverDefaultDoesNotRescheduleDefault() throws Exception {
     var count = new AtomicInteger(0);
 
     var resource = new HardwareResource("Resource", scheduler);
     var defaultCmd = resource.run(() -> {
-      count.incrementAndGet();
-      scheduler.pauseCurrentCommand(Milliseconds.of(50));
+      while (true) {
+        count.incrementAndGet();
+        scheduler.yield();
+      }
     }).named("Default Command");
 
-    var newerCmd = resource.run(scheduler::pauseCurrentCommand).named("Newer Command");
+    var newerCmd = resource.run(() -> {
+    }).named("Newer Command");
     resource.setDefaultCommand(defaultCmd);
-    assertTrue(scheduler.isRunning(defaultCmd));
+    scheduler.run();
+    assertTrue(scheduler.isRunning(defaultCmd), "Default command should be running");
 
     scheduler.schedule(newerCmd);
-    assertFalse(scheduler.isRunning(defaultCmd));
-    assertEquals(1, count.get());
+    scheduler.run();
+    assertFalse(scheduler.isRunning(defaultCmd), "Default command should have been interrupted");
+    assertEquals(1, count.get(), "Default command should have run once");
 
-    scheduler.await(newerCmd);
+    scheduler.run();
     assertTrue(scheduler.isRunning(defaultCmd));
   }
 
-  @RepeatedTest(value = 10, failureThreshold = 1)
+  @Test
   void cancelAllCancelsAll() {
     var commands = new ArrayList<AsyncCommand>(10);
     for (int i = 1; i <= 10; i++) {
-      commands.add(AsyncCommand.noHardware(AsyncCommand::pause).named("Command " + i));
+      commands.add(AsyncCommand.noHardware(scheduler::yield).named("Command " + i));
     }
     commands.forEach(scheduler::schedule);
+    scheduler.run();
     scheduler.cancelAll();
     for (AsyncCommand command : commands) {
       if (scheduler.isRunning(command)) {
@@ -280,7 +284,7 @@ void cancelAllCancelsAll() {
     }
   }
 
-  @RepeatedTest(value = 100, failureThreshold = 1)
+  @Test
   void cancelAllStartsDefaults() {
     var resources = new ArrayList<HardwareResource>(10);
     for (int i = 1; i <= 10; i++) {
@@ -290,61 +294,40 @@ void cancelAllStartsDefaults() {
     var command =
         new AsyncCommandBuilder()
             .requiring(resources)
-            .executing(AsyncCommand::pause)
+            .executing(scheduler::yield)
             .named("Big Command");
 
-    for (int i = 0; i < 10; i++) {
-      scheduler.schedule(command);
-      scheduler.cancelAll();
-
-      if (scheduler.isRunning(command)) {
-        System.err.println(scheduler.getRunningCommands());
-        fail("Run " + i + ": " + command.name() + " was not canceled by cancelAll()");
-      }
-
-      for (var resource : resources) {
-        if (!scheduler.isRunning(resource.getDefaultCommand())) {
-          System.err.println(Logger.formattedLogTable());
-          System.err.println("Running commands: " + scheduler.getRunningCommands());
-          fail("Run " + i + ": " + "Default command for " + resource.getName() + " should have been scheduled after cancelAll() was called");
-        }
-      }
-    }
-  }
-
-  static final class RunningCommand implements AsyncCommand {
-    private final Set<HardwareResource> subsystems;
-    boolean ran = false;
+    // Scheduling the command should evict the on-deck default commands
+    scheduler.schedule(command);
+    // Then running should get it into the set of running commands
+    scheduler.run();
+    // Cancelling should clear out the set of running commands
+    scheduler.cancelAll();
+    // Then ticking the scheduler once to fully remove the command and schedule the defaults
+    scheduler.run();
+    // Then one more tick to start running the scheduled defaults
+    scheduler.run();
 
-    RunningCommand(HardwareResource... subsystems) {
-      this.subsystems = Set.of(subsystems);
+    if (scheduler.isRunning(command)) {
+      System.err.println(scheduler.getRunningCommands());
+      fail(command.name() + " was not canceled by cancelAll()");
     }
 
-    @Override
-    public void run() throws Exception {
-      // Sleep and set the 'ran' flag only when interrupted
-      try {
-        AsyncCommand.pause(Milliseconds.of(Long.MAX_VALUE));
-      } finally {
-        ran = true;
+    for (var resource : resources) {
+      if (!scheduler.isRunning(resource.getDefaultCommand())) {
+        System.err.println(Logger.formattedLogTable());
+        System.err.println("Running commands: " + scheduler.getRunningCommands());
+        fail("Default command for " + resource.getName() + " should have been scheduled after cancelAll() was called");
       }
     }
-
-    @Override
-    public String name() {
-      return "RunningCommand";
-    }
-
-    @Override
-    public Set<HardwareResource> requirements() {
-      return subsystems;
-    }
   }
 
   record PriorityCommand(int priority, HardwareResource... subsystems) implements AsyncCommand {
     @Override
     public void run() throws Exception {
-      Thread.sleep(Long.MAX_VALUE);
+      while (true) {
+        AsyncScheduler.getInstance().yield();
+      }
     }
 
     @Override
diff --git a/wpilibNewCommands/src/test/java/edu/wpi/first/wpilibj3/command/async/ParallelGroupTest.java b/wpilibNewCommands/src/test/java/edu/wpi/first/wpilibj3/command/async/ParallelGroupTest.java
new file mode 100644
index 00000000000..5bd688dcb71
--- /dev/null
+++ b/wpilibNewCommands/src/test/java/edu/wpi/first/wpilibj3/command/async/ParallelGroupTest.java
@@ -0,0 +1,136 @@
+package edu.wpi.first.wpilibj3.command.async;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+class ParallelGroupTest {
+  private AsyncScheduler scheduler;
+
+  @BeforeEach
+  void setup() {
+    Logger.clear();
+
+    // Any command that calls AsyncCommand.park() or AsyncCommand.yield() uses the default
+    // scheduler instance. Notably, this includes commands with timeouts, wait commands, and
+    // the default idle commands
+    scheduler = new AsyncScheduler();
+    AsyncScheduler.setDefaultScheduler(scheduler);
+  }
+
+  @AfterEach
+  void printLogs() {
+    System.out.println(Logger.formattedLogTable());
+    Logger.clear();
+  }
+
+  @Test
+  void parallelAll() {
+    var r1 = new HardwareResource("R1", scheduler);
+    var r2 = new HardwareResource("R2", scheduler);
+
+    var c1Count = new AtomicInteger(0);
+    var c2Count = new AtomicInteger(0);
+
+    var c1 = r1.run(() -> {
+      for (int i = 0; i < 5; i++) {
+        scheduler.yield();
+        c1Count.incrementAndGet();
+      }
+    }).named("C1");
+    var c2 = r2.run(() -> {
+      for (int i = 0; i < 10; i++) {
+        scheduler.yield();
+        c2Count.incrementAndGet();
+      }
+    }).named("C2");
+
+    var parallel = new ParallelGroup("Parallel", scheduler, List.of(c1, c2), List.of(c1, c2));
+    scheduler.schedule(parallel);
+
+    // First call to run() should schedule the commands
+    scheduler.run();
+    assertTrue(scheduler.isRunning(parallel));
+    assertFalse(scheduler.isRunning(c1));
+    assertFalse(scheduler.isRunning(c2));
+
+    // Next call to run() should start them
+    for (int i = 0; i < 5; i++) {
+      scheduler.run();
+      assertTrue(scheduler.isRunning(c1));
+      assertTrue(scheduler.isRunning(c2));
+      assertEquals(i, c1Count.get());
+      assertEquals(i, c2Count.get());
+    }
+    // c1 should finish after 5 iterations; c2 should continue for another 5
+    for (int i = 5; i < 10; i++) {
+      scheduler.run();
+      assertFalse(scheduler.isRunning(c1));
+      assertTrue(scheduler.isRunning(c2));
+      assertEquals(5, c1Count.get());
+      assertEquals(i, c2Count.get());
+    }
+    // one final run() should unschedule the c2 command and then the parallel command
+    scheduler.run();
+    scheduler.run();
+    assertFalse(scheduler.isRunning(parallel));
+    assertFalse(scheduler.isRunning(c1));
+    assertFalse(scheduler.isRunning(c2));
+
+    // and final counts should be 5 and 10
+    assertEquals(5, c1Count.get());
+    assertEquals(10, c2Count.get());
+  }
+
+  @Test
+  void race() {
+    var r1 = new HardwareResource("R1", scheduler);
+    var r2 = new HardwareResource("R2", scheduler);
+
+    var c1Count = new AtomicInteger(0);
+    var c2Count = new AtomicInteger(0);
+
+    var c1 = r1.run(() -> {
+      for (int i = 0; i < 5; i++) {
+        scheduler.yield();
+        c1Count.incrementAndGet();
+      }
+    }).named("C1");
+    var c2 = r2.run(() -> {
+      for (int i = 0; i < 10; i++) {
+        scheduler.yield();
+        c2Count.incrementAndGet();
+      }
+    }).named("C2");
+
+    var race = new ParallelGroup("Race", scheduler, List.of(c1, c2), List.of());
+    scheduler.schedule(race);
+
+    // First call to run() should schedule the commands
+    scheduler.run();
+    assertTrue(scheduler.isRunning(race));
+    assertFalse(scheduler.isRunning(c1));
+    assertFalse(scheduler.isRunning(c2));
+
+    for (int i = 0; i < 5; i++) {
+      scheduler.run();
+      assertTrue(scheduler.isRunning(c1));
+      assertTrue(scheduler.isRunning(c2));
+      assertEquals(i, c1Count.get());
+      assertEquals(i, c2Count.get());
+    }
+    scheduler.run(); // complete c1
+    scheduler.run(); // complete parallel and cleanup
+    assertFalse(scheduler.isRunning(race));
+    assertFalse(scheduler.isRunning(c1));
+    assertFalse(scheduler.isRunning(c2));
+
+    // and final counts should be 5 and 5
+    assertEquals(5, c1Count.get());
+    assertEquals(5, c2Count.get());
+  }
+}
diff --git a/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/async/AsyncCommandBot.java b/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/async/AsyncCommandBot.java
index 4b9ebdf5be0..bf3e987e560 100644
--- a/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/async/AsyncCommandBot.java
+++ b/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/async/AsyncCommandBot.java
@@ -4,8 +4,6 @@
 
 package edu.wpi.first.wpilibj.examples.async;
 
-import static edu.wpi.first.units.Units.Milliseconds;
-
 import edu.wpi.first.wpilibj.examples.async.Constants.AutoConstants;
 import edu.wpi.first.wpilibj.examples.async.Constants.OIConstants;
 import edu.wpi.first.wpilibj.examples.async.Constants.ShooterConstants;
@@ -71,7 +69,7 @@ public void configureBindings() {
                 .requiring(m_shooter, m_storage)
                 .executing(() -> {
                   while (true) {
-                    AsyncCommand.pause(Milliseconds.of(10));
+                    AsyncCommand.yield();
                     m_storage.run();
                     m_shooter.ramp(ShooterConstants.kShooterTarget);
                     m_shooter.tryFeed();
diff --git a/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/async/Robot.java b/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/async/Robot.java
index 19f82c642fb..0839b18ed15 100644
--- a/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/async/Robot.java
+++ b/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/async/Robot.java
@@ -4,8 +4,8 @@
 
 package edu.wpi.first.wpilibj.examples.async;
 
+import edu.wpi.first.wpilibj.TimedRobot;
 import edu.wpi.first.wpilibj3.command.async.AsyncCommand;
-import edu.wpi.first.wpilibj3.command.async.AsyncRobot;
 import edu.wpi.first.wpilibj3.command.async.AsyncScheduler;
 
 /**
@@ -14,7 +14,7 @@
  * the package after creating this project, you must also update the build.gradle file in the
  * project.
  */
-public class Robot extends AsyncRobot {
+public class Robot extends TimedRobot {
   private AsyncCommand m_autonomousCommand;
 
   private final AsyncCommandBot m_robot = new AsyncCommandBot();
@@ -37,7 +37,9 @@ public void robotInit() {
    * SmartDashboard integrated updating.
    */
   @Override
-  public void robotPeriodic() {}
+  public void robotPeriodic() {
+    AsyncScheduler.getInstance().run();
+  }
 
   /** This function is called once each time the robot enters Disabled mode. */
   @Override
@@ -51,7 +53,7 @@ public void autonomousInit() {
     m_autonomousCommand = m_robot.getAutonomousCommand();
 
     if (m_autonomousCommand != null) {
-      scheduler.schedule(m_autonomousCommand);
+      AsyncScheduler.getInstance().schedule(m_autonomousCommand);
     }
   }
 
@@ -65,7 +67,7 @@ public void teleopInit() {
     // teleop starts running. If you want the autonomous to
     // continue until interrupted by another command, remove
     // this line or comment it out.
-    scheduler.cancel(m_autonomousCommand);
+    AsyncScheduler.getInstance().cancel(m_autonomousCommand);
   }
 
   /** This function is called periodically during operator control. */
diff --git a/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/async/subsystems/Drive.java b/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/async/subsystems/Drive.java
index 747169bbe46..d10f502c30b 100644
--- a/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/async/subsystems/Drive.java
+++ b/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/async/subsystems/Drive.java
@@ -5,7 +5,6 @@
 package edu.wpi.first.wpilibj.examples.async.subsystems;
 
 import static edu.wpi.first.units.Units.Meters;
-import static edu.wpi.first.wpilibj3.command.async.AsyncCommand.pause;
 
 import edu.wpi.first.units.Distance;
 import edu.wpi.first.units.Measure;
@@ -92,7 +91,7 @@ public AsyncCommand driveDistanceCommand(Measure<Distance> distance, double spee
       m_rightEncoder.reset();
 
       while (Math.max(m_leftEncoder.getDistance(), m_rightEncoder.getDistance()) < distanceMeters) {
-        pause();
+        AsyncCommand.yield();
         m_drive.arcadeDrive(speed, 0);
       }
 
diff --git a/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/async/subsystems/Intake.java b/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/async/subsystems/Intake.java
index c7214dbef4f..deb18b156f5 100644
--- a/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/async/subsystems/Intake.java
+++ b/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/async/subsystems/Intake.java
@@ -5,7 +5,6 @@
 package edu.wpi.first.wpilibj.examples.async.subsystems;
 
 import static edu.wpi.first.wpilibj.examples.async.Constants.IntakeConstants;
-import static edu.wpi.first.wpilibj3.command.async.AsyncCommand.pause;
 
 import edu.wpi.first.wpilibj.DoubleSolenoid;
 import edu.wpi.first.wpilibj.PneumaticsModuleType;
@@ -32,7 +31,7 @@ public AsyncCommand intakeCommand() {
     return run(() -> {
       m_pistons.set(DoubleSolenoid.Value.kForward);
       while (true) {
-        pause();
+        AsyncCommand.yield();
         m_motor.set(1);
       }
     }).named("Intake");
diff --git a/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/async/subsystems/Pneumatics.java b/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/async/subsystems/Pneumatics.java
index f3e46c596bd..d98fda6a439 100644
--- a/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/async/subsystems/Pneumatics.java
+++ b/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/async/subsystems/Pneumatics.java
@@ -53,10 +53,8 @@ public AsyncCommand disableCompressorCommand() {
     return run(() -> {
       m_compressor.disable();
 
-      try {
-        Thread.sleep(Long.MAX_VALUE);
-      } finally {
-        m_compressor.enableDigital();
+      while (true) {
+        AsyncCommand.yield();
       }
     }).named("Compressor Disabled");
   }
diff --git a/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/async/subsystems/Shooter.java b/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/async/subsystems/Shooter.java
index b3f931b617e..c2d99e40559 100644
--- a/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/async/subsystems/Shooter.java
+++ b/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/async/subsystems/Shooter.java
@@ -4,9 +4,7 @@
 
 package edu.wpi.first.wpilibj.examples.async.subsystems;
 
-import static edu.wpi.first.units.Units.Milliseconds;
 import static edu.wpi.first.units.Units.RotationsPerSecond;
-import static edu.wpi.first.wpilibj3.command.async.AsyncCommand.pause;
 
 import edu.wpi.first.math.controller.PIDController;
 import edu.wpi.first.math.controller.SimpleMotorFeedforward;
@@ -44,7 +42,7 @@ public Shooter() {
         () -> {
           m_shooterMotor.disable();
           m_feederMotor.disable();
-          Thread.sleep(Long.MAX_VALUE);
+          AsyncCommand.park();
         })
         .named("Idle"));
   }
diff --git a/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/async/subsystems/Storage.java b/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/async/subsystems/Storage.java
index fdc07fec385..87441179ac8 100644
--- a/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/async/subsystems/Storage.java
+++ b/wpilibjExamples/src/main/java/edu/wpi/first/wpilibj/examples/async/subsystems/Storage.java
@@ -42,7 +42,7 @@ public void run() throws InterruptedException {
   public AsyncCommand runCommand() {
     return run(() -> {
       while (true) {
-        AsyncCommand.pause();
+        AsyncCommand.yield();
         run();
       }
     }).named("Run");