Need help with awaitable tasks

So as written, I do not think your PseudoTaskX methods are very useful. You've marked them as async, but you're not using an await. The whole purpose of marking a method as async is so that you can use the await keyword within the method. You can actually see this within the warning that VS adds to the method name (i.e. the green squiggly). If you're not going to use await, then don't tack on the async. (This won't affect the fact that you're returning a Task...assuming you are returning one; I've changed your methods slightly below.)

public class AsyncThingy
{
    Random rand = new Random();

    public AsyncStatus PseudoTask(string someInput, AsyncProgress<AsyncStatus> progress, CancellationToken cToken)
    {
        AsyncStatus status = new AsyncStatus();
        status.Context = someInput;
        status.Status = "Initializing 1...";
        progress?.Report(status);
        Thread.Sleep(rand.Next(250, 1000));
        status.Status = "Working 1...";
        progress?.Report(status);
        Thread.Sleep(rand.Next(250, 1000));
        int taskRuntime = new Random().Next(5, 15);
        double currentTimeIndex = 0;
        DateTime timeToStop = DateTime.Now.AddSeconds(taskRuntime);
        do
        {
            cToken.ThrowIfCancellationRequested();
            currentTimeIndex = (timeToStop - DateTime.Now).TotalSeconds;
            status.PercentComplete = (int)((taskRuntime - currentTimeIndex) / taskRuntime * 100);
            progress?.Report(status);
            Thread.Sleep(rand.Next(250, 1000));
        } while (DateTime.Now < timeToStop);
        status.PercentComplete = 100;
        status.Status = "Finished";
        progress.Report(status);
        return status;
    }

    public AsyncStatus PseudoTask2(string someInput, AsyncProgress<AsyncStatus> progress, CancellationToken cToken)
    {
        AsyncStatus status = new AsyncStatus();
        status.Status = "Initializing 2...";
        status.Context = someInput;
        progress?.Report(status);
        Thread.Sleep(rand.Next(250, 1000));
        status.Status = "Working 2...";
        progress?.Report(status);
        int taskRuntime = new Random().Next(5, 15);
        double currentTimeIndex = 0;
        DateTime timeToStop = DateTime.Now.AddSeconds(taskRuntime);
        do
        {
            cToken.ThrowIfCancellationRequested();
            currentTimeIndex = (timeToStop - DateTime.Now).TotalSeconds;
            status.PercentComplete = (int)((taskRuntime - currentTimeIndex) / taskRuntime * 100);
            progress?.Report(status);
            Thread.Sleep(rand.Next(250, 1000));
        } while (DateTime.Now < timeToStop);
        status.PercentComplete = 100;
        status.Status = "Finished";
        progress.Report(status);
        return status;
    }

    public AsyncStatus PseudoTask3(string someInput, AsyncProgress<AsyncStatus> progress, CancellationToken cToken)
    {
        AsyncStatus status = new AsyncStatus();
        status.Status = "Initializing 3...";
        status.Context = someInput;
        progress?.Report(status);
        Thread.Sleep(rand.Next(250, 1000));
        status.Status = "Working 3...";
        progress?.Report(status);
        int taskRuntime = new Random().Next(5, 15);
        double currentTimeIndex = 0;
        DateTime timeToStop = DateTime.Now.AddSeconds(taskRuntime);
        do
        {
            cToken.ThrowIfCancellationRequested();
            currentTimeIndex = (timeToStop - DateTime.Now).TotalSeconds;
            status.PercentComplete = (int)((taskRuntime - currentTimeIndex) / taskRuntime * 100);
            progress?.Report(status);
            Thread.Sleep(rand.Next(250, 1000));
        } while (DateTime.Now < timeToStop);
        status.PercentComplete = 100;
        status.Status = "Finished";
        progress.Report(status);
        return status;
    }
}

Select all Open in new window

Now the work that's being done inside of each "pseudotask" appears to be all CPU-bound, especially considering your usage of Thread.Sleep. For this reason, it would seem to make more sense to use a Task.Run call outside of these methods within RunMutlipleTasks:

public async Task<AsyncStatus> RunMultipleTasks(AsyncProgress<AsyncStatus> progress, CancellationToken cToken)
{
    AsyncThingy thingy = new AsyncThingy();
    AsyncStatus overallStatus = new AsyncStatus();
    var localProgress = new AsyncProgress<AsyncStatus>(ReportProgress);
    List<Task<AsyncStatus>> taskList = new List<Task<AsyncStatus>>()
    {
        Task.Run(() => thingy.PseudoTask("1", localProgress, cToken), cToken),
        Task.Run(() => thingy.PseudoTask2("2", localProgress, cToken), cToken),
        Task.Run(() => thingy.PseudoTask3("3", localProgress, cToken), cToken),
    };

    try
    {
        await Task.WhenAll(taskList);
    }
    catch (Exception ex)
    {
        System.Diagnostics.Debug.Print(ex.Message);
    }

    return overallStatus;
}

Select all Open in new window

You'll get the benefit of running on a new thread for each call, and you'll get back a task that you can await. You can ditch the Task.Run call that's in the button click handler--just await the call to the method directly:

private async void buttonDoManyThings_Click(object sender, EventArgs e)
{
    buttonDoManyThings.Enabled = false;
    _cts = new CancellationTokenSource();
    var progressIndicator = new AsyncProgress<AsyncStatus>(ReportProgress);
    await multiTaskThingy.RunMultipleTasks(progressIndicator, _cts.Token);
    _cts.Dispose();
    _cts = null;
    buttonDoManyThings.Enabled = true;
}

Select all Open in new window

This should get you closer to what you're after. I have to slide in two caveats, though:  It's been a few years since I've done WinForms, and my thread-fu is not strong. The above seems to work and mimic what you're looking for, but I haven't exhaustively tested it. You'll surely want to before migrating something similar to production.