Architecting Autonomous Multi-Agent Workflows in .NET 10: Combining C# Type Safety with LangGraph & Native AOT

// High-Performance Strongly-Typed Agent State Graph in .NET 10
using System.Collections.Immutable;
using Microsoft.Extensions.AI;

public readonly record struct AgentExecutionContext(
    string SessionId,
    string OriginalPrompt,
    string TargetIntent,
    ImmutableList<AgentThoughtNode> ExecutionHistory,
    int ReflectionIterationCount,
    double ConfidenceScore,
    bool IsVerified
);

public interface IAgentGraphNode
{
    string NodeIdentifier { get; }
    ValueTask<AgentExecutionContext> ExecuteAsync(
        AgentExecutionContext context,
        IChatClient chatClient,
        CancellationToken cancellationToken = default
    );
}

// Reflection Node validating output against enterprise compliance schema
public sealed class ComplianceVerifierNode : IAgentGraphNode
{
    public string NodeIdentifier => "compliance-verification-node";

    public async ValueTask<AgentExecutionContext> ExecuteAsync(
        AgentExecutionContext context,
        IChatClient chatClient,
        CancellationToken cancellationToken = default)
    {
        var response = await chatClient.GetResponseAsync(
            [
                new ChatMessage(ChatRole.System, "You are a strict compliance auditor. Score groundedness from 0.0 to 1.0."),
                new ChatMessage(ChatRole.User, $"Verify output against context: {context.TargetIntent}")
            ],
            new ChatOptions { Temperature = 0.0f },
            cancellationToken
        );

        double score = ParseConfidenceScore(response.Text);
        bool isPassing = score >= 0.88;

        return context with
        {
            ConfidenceScore = score,
            IsVerified = isPassing,
            ReflectionIterationCount = context.ReflectionIterationCount + 1
        };
    }

    private static double ParseConfidenceScore(string? text) =>
        double.TryParse(text?.Trim(), out var s) ? s : 0.0;
}

// Deterministic Conditional Edge Router
public static class GraphEdgeRouter
{
    private const int MaxAllowedReflections = 3;

    public static string RouteNextStep(AgentExecutionContext context)
    {
        if (context.IsVerified)
        {
            return "final-publisher-node"; // Exit condition satisfied
        }

        if (context.ReflectionIterationCount >= MaxAllowedReflections)
        {
            // Safeguard: Fallback to Human-in-the-Loop review rather than infinite loop
            return "escalate-human-review-node";
        }

        // Cycle back to query reformulation
        return "query-reformulation-node";
    }
}

<Project Sdk="Microsoft.NET.Sdk.Web">
  <PropertyGroup>
    <TargetFramework>net10.0</TargetFramework>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
    <PublishAot>true</PublishAot>
    <InvariantGlobalization>false</InvariantGlobalization>
    <OptimizationPreference>Speed</OptimizationPreference>
    <StackTraceSupport>false</StackTraceSupport>
  </PropertyGroup>
</Project>