Clarify IResettableExecutor usage comment in workflow sample

dotnet/samples/03-workflows/Agents/WorkflowAsAnAgent/Program.cs

@@ -9,7 +9,7 @@ using Microsoft.Extensions.AI;
 namespace WorkflowAsAnAgentSample;
 
 /// <summary>
-/// This sample introduces the concepts workflows as agents, where a workflow can be
+/// This sample introduces the concept of workflows as agents, where a workflow can be
 /// treated as an <see cref="AIAgent"/>. This allows you to interact with a workflow
 /// as if it were a single agent.
 ///
@@ -18,6 +18,14 @@ namespace WorkflowAsAnAgentSample;
 ///
 /// You will interact with the workflow in an interactive loop, sending messages and receiving
 /// streaming responses from the workflow as if it were an agent who responds in both languages.
+///
+/// This sample also demonstrates <see cref="IResettableExecutor"/>, which is required
+/// for stateful executors that are shared across multiple workflow runs. Each iteration
+/// of the interactive loop triggers a new workflow run against the same workflow instance.
+/// Between runs, the framework automatically calls <see cref="IResettableExecutor.ResetAsync"/>
+/// on shared executors so that accumulated state (e.g., collected messages) is cleared
+/// before the next run begins. See <c>WorkflowFactory.ConcurrentAggregationExecutor</c>
+/// for the implementation.
 /// </summary>
 /// <remarks>
 /// Pre-requisites:
@@ -39,7 +47,10 @@ public static class Program
         var agent = workflow.AsAIAgent("workflow-agent", "Workflow Agent");
         var session = await agent.CreateSessionAsync();
 
-        // Start an interactive loop to interact with the workflow as if it were an agent
+        // Start an interactive loop to interact with the workflow as if it were an agent.
+        // Each iteration runs the workflow again on the same workflow instance. Between runs,
+        // the framework calls IResettableExecutor.ResetAsync() on shared stateful executors
+        // (like ConcurrentAggregationExecutor) to clear accumulated state from the previous run.
         while (true)
         {
             Console.WriteLine();

dotnet/samples/03-workflows/Agents/WorkflowAsAnAgent/WorkflowFactory.cs

@@ -10,6 +10,12 @@ internal static class WorkflowFactory
 {
     /// <summary>
     /// Creates a workflow that uses two language agents to process input concurrently.
+    ///
+    /// The executors in this workflow are provided as shared instances, meaning the same
+    /// executor objects are reused across multiple workflow runs. Stateful executors must
+    /// implement <see cref="IResettableExecutor"/> so the framework can clear their state
+    /// between runs. Framework-provided executors like <see cref="ChatForwardingExecutor"/>
+    /// already implement this interface.
     /// </summary>
     /// <param name="chatClient">The chat client to use for the agents</param>
     /// <returns>A workflow that processes input using two language agents</returns>
@@ -40,6 +46,15 @@ internal static class WorkflowFactory
 
     /// <summary>
     /// Executor that aggregates the results from the concurrent agents.
+    ///
+    /// This executor is stateful — it accumulates messages in <see cref="_messages"/>
+    /// as they arrive from each agent. Because it is provided as a shared instance
+    /// (not via a factory), the same object is reused across workflow runs. Implementing
+    /// <see cref="IResettableExecutor"/> allows the framework to call <see cref="ResetAsync"/>
+    /// between runs, clearing accumulated state so each run starts fresh.
+    ///
+    /// Without <see cref="IResettableExecutor"/>, attempting to reuse a workflow containing
+    /// shared stateful executor instances would throw an <see cref="InvalidOperationException"/>.
     /// </summary>
     [YieldsOutput(typeof(string))]
     private sealed class ConcurrentAggregationExecutor() :
@@ -65,7 +80,11 @@ internal static class WorkflowFactory
             }
         }
 
-        /// <inheritdoc/>
+        /// <summary>
+        /// Resets the executor state between workflow runs by clearing accumulated messages.
+        /// The framework calls this automatically when a workflow run completes, before the
+        /// workflow can be used for another run.
+        /// </summary>
         public ValueTask ResetAsync()
         {
             this._messages.Clear();