action.json

{
    "Name": "Complex Calculation",
    "Version": "1.8",
    "Steps": [
        {
            "Action": "Add", 
            "Param": 5
        },
        {
            "Action": "Add", 
            "Param": 1
        }
...
    ]
}

actions.cs

[FunctionName("Add")]
public static async Task<int> Add([ActivityTrigger] (int a, int b) numbers)
{
    return numbers.a + numbers.b;
}
 
[FunctionName("Subtract")]
public static async Task<int> Subtract([ActivityTrigger] (int a, int b) numbers)
{
    return numbers.a - numbers.b;
}
 
[FunctionName("Multiply")]
public static async Task<int> Multiply([ActivityTrigger] (int a, int b) numbers)
{
    return numbers.a * numbers.b;
}
 
[FunctionName("Divide")]
public static async Task<int> Divide([ActivityTrigger] (int a, int b) numbers)
{
    return numbers.a / numbers.b;
}

orchestrator.cs

[FunctionName("FlowMaker")]
public static async Task<int> Run([OrchestrationTrigger] IDurableOrchestrationContext context)
{
    // imagine this comes from an api call or cosmos or something
    var steps = new DynamicFlowContext
    {
        Steps = new List<DynamicStep<int>>
        {
            new DynamicStep<int>(ActionName.Add, 1),
            new DynamicStep<int>(ActionName.Add, 1),
            new DynamicStep<int>(ActionName.Subtract, 1),
            new DynamicStep<int>(ActionName.Multiply, 10)
        }
    };
 
    var result = await context.CallSubOrchestratorAsync<DynamicResult<int>>("DynamicOrchestrator", steps);
    return result.Result;
}

steps.cs

public class DynamicStep<T>
{
    public string Action { get; private set; }
    public T param { get; private set; }
 
    [JsonConstructor]
    public DynamicStep(string action, T param)
    {
        Action = action;
        this.param = param;
    }
}
 
public class DynamicResult<T>
{
    public T Result { get; set; }
}
 
public static class ActionName
{
    public const string Add = "Add";
    public const string Subtract = "Subtract";
    public const string Multiply = "Multiply";
    public const string Divide = "Divide";
}

Suborchestrator.cs

[FunctionName("DynamicOrchestrator")]
public static async Task<DynamicResult<int>> RunInnerOrchestrator([OrchestrationTrigger] IDurableOrchestrationContext ctx)
{
    var input = ctx.GetInput<DynamicFlowContext>();
    int state = 0;
 
    foreach (var step in input.Steps)
    {
        state = await ctx.CallActivityAsync<int>(step.Action, (state, step.param));
    }
 
    return new DynamicResult<int>
    {
        Result = state
    };
}