diff --git a/dotnet/src/Microsoft.Agents.AI.Workflows/Specialized/HandoffAgentExecutor.cs b/dotnet/src/Microsoft.Agents.AI.Workflows/Specialized/HandoffAgentExecutor.cs
index d1367b83ad..9883358e9e 100644
--- a/dotnet/src/Microsoft.Agents.AI.Workflows/Specialized/HandoffAgentExecutor.cs
+++ b/dotnet/src/Microsoft.Agents.AI.Workflows/Specialized/HandoffAgentExecutor.cs
@@ -250,7 +250,18 @@ internal sealed class HandoffAgentExecutor(
             }
         }
 
-        allMessages.AddRange(updates.ToAgentResponse().Messages);
+        AgentResponse agentResponse = updates.ToAgentResponse();
+
+        // Since there is no good way to configure the agent output behaviour due to how we add it to Handoff orchestration
+        // configurations, treat the emitEvents flag as simply determining whether to stream updates or to emit the whole response
+        // It would make little sense to avoid emitting any agent responses since this is only used in Orchestration workflows,
+        // which are Agent-only, and thus would do nothing.
+        if (message.TurnToken.EmitEvents is not true)
+        {
+            await context.YieldOutputAsync(agentResponse, cancellationToken).ConfigureAwait(false);
+        }
+
+        allMessages.AddRange(agentResponse.Messages);
 
         roleChanges.ResetUserToAssistantForChangedRoles();
 
diff --git a/dotnet/tests/Microsoft.Agents.AI.Workflows.UnitTests/AIAgentHostExecutorTests.cs b/dotnet/tests/Microsoft.Agents.AI.Workflows.UnitTests/AIAgentHostExecutorTests.cs
index 063bd77cda..f6d48062b3 100644
--- a/dotnet/tests/Microsoft.Agents.AI.Workflows.UnitTests/AIAgentHostExecutorTests.cs
+++ b/dotnet/tests/Microsoft.Agents.AI.Workflows.UnitTests/AIAgentHostExecutorTests.cs
@@ -10,10 +10,10 @@ using Microsoft.Extensions.AI;
 
 namespace Microsoft.Agents.AI.Workflows.UnitTests;
 
-public class AIAgentHostExecutorTests
+public abstract class AIAgentHostingExecutorTestsBase
 {
-    private const string TestAgentId = nameof(TestAgentId);
-    private const string TestAgentName = nameof(TestAgentName);
+    protected const string TestAgentId = nameof(TestAgentId);
+    protected const string TestAgentName = nameof(TestAgentName);
 
     private static readonly string[] s_messageStrings = [
         "",
@@ -22,8 +22,96 @@ public class AIAgentHostExecutorTests
         "Quisque dignissim ante odio, at facilisis orci porta a. Duis mi augue, fringilla eu egestas a, pellentesque sed lacus."
     ];
 
-    private static List<ChatMessage> TestMessages => TestReplayAgent.ToChatMessages(s_messageStrings);
+    protected static List<ChatMessage> TestMessages => TestReplayAgent.ToChatMessages(s_messageStrings);
 
+    protected static void CheckResponseUpdateEventsAgainstTestMessages(AgentResponseUpdateEvent[] updates, bool expectingEvents, string expectedExecutorId)
+    {
+        if (expectingEvents)
+        {
+            // The way TestReplayAgent is set up, it will emit one update per non-empty AIContent
+            List<AIContent> expectedUpdateContents = TestMessages.SelectMany(message => message.Contents).ToList();
+
+            updates.Should().HaveCount(expectedUpdateContents.Count);
+            for (int i = 0; i < updates.Length; i++)
+            {
+                AgentResponseUpdateEvent updateEvent = updates[i];
+                AIContent expectedUpdateContent = expectedUpdateContents[i];
+
+                updateEvent.ExecutorId.Should().Be(expectedExecutorId);
+
+                AgentResponseUpdate update = updateEvent.Update;
+                update.AuthorName.Should().Be(TestAgentName);
+                update.AgentId.Should().Be(TestAgentId);
+                update.Contents.Should().HaveCount(1);
+                update.Contents[0].Should().BeEquivalentTo(expectedUpdateContent);
+            }
+        }
+        else
+        {
+            updates.Should().BeEmpty();
+        }
+    }
+
+    protected static void CheckResponseEventsAgainstTestMessages(AgentResponseEvent[] updates, bool expectingResponse, string expectedExecutorId)
+    {
+        if (expectingResponse)
+        {
+            updates.Should().HaveCount(1);
+
+            AgentResponseEvent responseEvent = updates[0];
+            responseEvent.ExecutorId.Should().Be(expectedExecutorId);
+
+            AgentResponse response = responseEvent.Response;
+            response.AgentId.Should().Be(TestAgentId);
+            response.Messages.Should().HaveCount(TestMessages.Count - 1);
+
+            for (int i = 0; i < response.Messages.Count; i++)
+            {
+                ChatMessage responseMessage = response.Messages[i];
+                ChatMessage expectedMessage = TestMessages[i + 1]; // Skip the first empty message
+
+                responseMessage.AuthorName.Should().Be(TestAgentName);
+                responseMessage.Text.Should().Be(expectedMessage.Text);
+            }
+        }
+        else
+        {
+            updates.Should().BeEmpty();
+        }
+    }
+}
+
+public class HandoffAgentExecutorTests : AIAgentHostingExecutorTestsBase
+{
+    [Theory]
+    [InlineData(null)]
+    [InlineData(true)]
+    [InlineData(false)]
+    public async Task Test_HandoffAgentExecutor_EmitsCorrectOutputTypeAsync(bool? turnSetting)
+    {
+        // Arrange
+        TestRunContext testContext = new();
+        TestReplayAgent agent = new(TestMessages, TestAgentId, TestAgentName);
+        HandoffAgentExecutor executor = new(agent, new("", HandoffToolCallFilteringBehavior.None));
+        testContext.ConfigureExecutor(executor);
+
+        // Act
+        HandoffState message = new(new(turnSetting), null, []);
+        await executor.HandleAsync(message, testContext.BindWorkflowContext(executor.Id));
+
+        // Assert
+        bool expectingStreamingUpdates = turnSetting is true;
+
+        AgentResponseEvent[] responses = testContext.Events.OfType<AgentResponseEvent>().ToArray();
+        CheckResponseEventsAgainstTestMessages(responses, !expectingStreamingUpdates, agent.GetDescriptiveId());
+
+        AgentResponseUpdateEvent[] updates = testContext.Events.OfType<AgentResponseUpdateEvent>().ToArray();
+        CheckResponseUpdateEventsAgainstTestMessages(updates, expectingStreamingUpdates, agent.GetDescriptiveId());
+    }
+}
+
+public class AIAgentHostExecutorTests : AIAgentHostingExecutorTestsBase
+{
     [Theory]
     [InlineData(null, null)]
     [InlineData(null, true)]
@@ -50,30 +138,7 @@ public class AIAgentHostExecutorTests
         bool expectingEvents = turnSetting ?? executorSetting ?? false;
 
         AgentResponseUpdateEvent[] updates = testContext.Events.OfType<AgentResponseUpdateEvent>().ToArray();
-        if (expectingEvents)
-        {
-            // The way TestReplayAgent is set up, it will emit one update per non-empty AIContent
-            List<AIContent> expectedUpdateContents = TestMessages.SelectMany(message => message.Contents).ToList();
-
-            updates.Should().HaveCount(expectedUpdateContents.Count);
-            for (int i = 0; i < updates.Length; i++)
-            {
-                AgentResponseUpdateEvent updateEvent = updates[i];
-                AIContent expectedUpdateContent = expectedUpdateContents[i];
-
-                updateEvent.ExecutorId.Should().Be(agent.GetDescriptiveId());
-
-                AgentResponseUpdate update = updateEvent.Update;
-                update.AuthorName.Should().Be(TestAgentName);
-                update.AgentId.Should().Be(TestAgentId);
-                update.Contents.Should().HaveCount(1);
-                update.Contents[0].Should().BeEquivalentTo(expectedUpdateContent);
-            }
-        }
-        else
-        {
-            updates.Should().BeEmpty();
-        }
+        CheckResponseUpdateEventsAgainstTestMessages(updates, expectingEvents, agent.GetDescriptiveId());
     }
 
     [Theory]
@@ -92,30 +157,7 @@ public class AIAgentHostExecutorTests
 
         // Assert
         AgentResponseEvent[] updates = testContext.Events.OfType<AgentResponseEvent>().ToArray();
-        if (executorSetting)
-        {
-            updates.Should().HaveCount(1);
-
-            AgentResponseEvent responseEvent = updates[0];
-            responseEvent.ExecutorId.Should().Be(agent.GetDescriptiveId());
-
-            AgentResponse response = responseEvent.Response;
-            response.AgentId.Should().Be(TestAgentId);
-            response.Messages.Should().HaveCount(TestMessages.Count - 1);
-
-            for (int i = 0; i < response.Messages.Count; i++)
-            {
-                ChatMessage responseMessage = response.Messages[i];
-                ChatMessage expectedMessage = TestMessages[i + 1]; // Skip the first empty message
-
-                responseMessage.AuthorName.Should().Be(TestAgentName);
-                responseMessage.Text.Should().Be(expectedMessage.Text);
-            }
-        }
-        else
-        {
-            updates.Should().BeEmpty();
-        }
+        CheckResponseEventsAgainstTestMessages(updates, expectingResponse: executorSetting, agent.GetDescriptiveId());
     }
 
     private static ChatMessage UserMessage => new(ChatRole.User, "Hello from User!") { AuthorName = "User" };