diff --git a/PanoramicData.Blazor.Test/Components/PDChatTests.Agents.cs b/PanoramicData.Blazor.Test/Components/PDChatTests.Agents.cs
new file mode 100644
index 000000000..095de2328
--- /dev/null
+++ b/PanoramicData.Blazor.Test/Components/PDChatTests.Agents.cs
@@ -0,0 +1,90 @@
+using AwesomeAssertions;
+using Bunit;
+using Microsoft.AspNetCore.Components;
+using PanoramicData.Blazor.Interfaces;
+using PanoramicData.Blazor.Models;
+
+namespace PanoramicData.Blazor.Test;
+
+/// <summary>
+/// The agent picker: offered in the input area only when the service lists two or more agents, and choosing one sets
+/// <see cref="IChatService.SelectedAgentId"/>.
+/// </summary>
+public partial class PDChatTests
+{
+	private static readonly PDChatAgentOption _merlin = new("merlin", "Merlin", "Answers about the product", "/merlin.png");
+	private static readonly PDChatAgentOption _alice = new("alice", "Alice", "Development help");
+
+	/// <summary>Verifies that no picker is shown with no agents, or with only one to choose.</summary>
+	[Theory]
+	[InlineData(0)]
+	[InlineData(1)]
+	public void The_agent_picker_is_hidden_with_fewer_than_two_agents(int count)
+	{
+		var component = RenderChat(new FakeChatService { Agents = [.. new[] { _merlin, _alice }.Take(count)] });
+
+		component.FindAll(".pdchat-agent-picker").Should().BeEmpty();
+		component.FindAll(".chat-input-accessories").Should().BeEmpty("there is nothing else to show there");
+	}
+
+	/// <summary>Verifies that no picker is shown when the service does not list agents at all.</summary>
+	[Fact]
+	public void The_agent_picker_is_hidden_without_agents()
+		=> RenderChat(new FakeChatService()).FindAll(".pdchat-agent-picker").Should().BeEmpty();
+
+	/// <summary>Verifies that two or more agents are offered in the input area, the first selected by default.</summary>
+	[Fact]
+	public void The_agent_picker_is_shown_in_the_input_area_with_two_agents()
+	{
+		var component = RenderChat(new FakeChatService { Agents = [_merlin, _alice] });
+
+		var select = component.Find(".chat-input-container .chat-input-accessories .pdchat-agent-picker select");
+		select.GetAttribute("title").Should().Be("Who you are talking to");
+		var options = select.QuerySelectorAll("option");
+		options.Select(option => option.TextContent).Should().Equal("Merlin", "Alice");
+		options.Select(option => option.GetAttribute("value")).Should().Equal("merlin", "alice");
+		options[0].GetAttribute("title").Should().Be("Answers about the product");
+		options[0].HasAttribute("selected").Should().BeTrue();
+		component.Find(".pdchat-agent-icon").GetAttribute("src").Should().Be("/merlin.png");
+	}
+
+	/// <summary>Verifies that choosing an agent sets the service's selected agent, and the picker follows it.</summary>
+	[Fact]
+	public async Task Choosing_an_agent_sets_the_selected_agent()
+	{
+		var service = new FakeChatService { Agents = [_merlin, _alice] };
+		var component = RenderChat(service);
+		((IChatService)service).SelectedAgentId.Should().BeNull();
+
+		await component.Find(".pdchat-agent-picker select").ChangeAsync(new ChangeEventArgs { Value = "alice" });
+
+		((IChatService)service).SelectedAgentId.Should().Be("alice");
+		component.WaitForAssertion(() => component.Find("option[value='alice']").HasAttribute("selected").Should().BeTrue(), Patience);
+		component.FindAll(".pdchat-agent-icon").Should().BeEmpty("Alice has no icon");
+	}
+
+	/// <summary>Verifies that a value that is not one of the agents is ignored.</summary>
+	[Fact]
+	public async Task An_unknown_agent_is_not_selected()
+	{
+		var service = new FakeChatService { Agents = [_merlin, _alice] };
+		var component = RenderChat(service);
+
+		await component.Find(".pdchat-agent-picker select").ChangeAsync(new ChangeEventArgs { Value = "mallory" });
+
+		((IChatService)service).SelectedAgentId.Should().BeNull();
+	}
+
+	/// <summary>Verifies that the picker and the Voice control share the input area.</summary>
+	[Fact]
+	public void The_agent_picker_sits_beside_the_Voice_control()
+	{
+		var service = VoiceService();
+		service.Agents = [_merlin, _alice];
+
+		var accessories = RenderChat(service).Find(".chat-input-accessories");
+
+		accessories.QuerySelector(".pdchat-agent-picker").Should().NotBeNull();
+		accessories.QuerySelector(".pdchat-voice-toggle").Should().NotBeNull();
+	}
+}
diff --git a/PanoramicData.Blazor.Test/Components/PDChatTests.Fakes.cs b/PanoramicData.Blazor.Test/Components/PDChatTests.Fakes.cs
index 34a56d816..319da5a7a 100644
--- a/PanoramicData.Blazor.Test/Components/PDChatTests.Fakes.cs
+++ b/PanoramicData.Blazor.Test/Components/PDChatTests.Fakes.cs
@@ -55,6 +55,7 @@ private sealed partial class FakeChatService : IChatService
 		public int ToastMaxVisible { get; set; } = 3;
 		public PDChatButtonPosition ToastAnchor { get; set; } = PDChatButtonPosition.BottomRight;
 		public PDChatVoiceEndpoints? VoiceEndpoints { get; set; }
+		public IReadOnlyList<PDChatAgentOption>? Agents { get; set; }
 
 		public IReadOnlyList<ChatMessage> Messages => Store;
 		public bool SupportsConversations { get; init; }
diff --git a/PanoramicData.Blazor.Test/Components/PDChatTests.Voice.cs b/PanoramicData.Blazor.Test/Components/PDChatTests.Voice.cs
index 45d527daa..220e58702 100644
--- a/PanoramicData.Blazor.Test/Components/PDChatTests.Voice.cs
+++ b/PanoramicData.Blazor.Test/Components/PDChatTests.Voice.cs
@@ -1,5 +1,6 @@
 using AwesomeAssertions;
 using Bunit;
+using Microsoft.AspNetCore.Components.Web;
 using Microsoft.JSInterop;
 using PanoramicData.Blazor.Interfaces;
 using PanoramicData.Blazor.Models;
@@ -7,14 +8,17 @@
 namespace PanoramicData.Blazor.Test;
 
 /// <summary>
-/// Voice Mode: offered only when the service supplies endpoints, off by default, and when on, a spoken question is
-/// sent like a typed one and the first finished reply is read aloud.
+/// Voice Mode: offered in the input area only when the service supplies endpoints, off by default. When on, words are
+/// dictated into the text box, sent after a pause unless the user is editing, and the first finished reply is read aloud.
 /// </summary>
 public partial class PDChatTests
 {
 	private const string VoiceModulePath = "./_content/PanoramicData.Blazor/js/pdchat-voice.js";
 	private static readonly PDChatVoiceEndpoints _voiceEndpoints = new("/voice/listen", "/voice/speak");
 
+	/// <summary>Long enough that a send which should not happen would have.</summary>
+	private static readonly TimeSpan _settle = TimeSpan.FromMilliseconds(400);
+
 	/// <summary>Verifies that a service without voice endpoints offers no Voice Mode at all.</summary>
 	[Fact]
 	public void Without_voice_endpoints_there_is_no_Voice_Mode_control()
@@ -24,21 +28,57 @@ public void Without_voice_endpoints_there_is_no_Voice_Mode_control()
 	[Fact]
 	public void Voice_Mode_is_offered_but_off_by_default()
 	{
-		var component = RenderChat(new FakeChatService { VoiceEndpoints = _voiceEndpoints });
+		var component = RenderChat(VoiceService());
 
 		var toggle = component.Find(".pdchat-voice-toggle");
 		toggle.TextContent.Should().Contain("Voice");
-		toggle.GetAttribute("title").Should().Be("Turn Voice Mode on: ask out loud and hear the answer");
+		toggle.GetAttribute("title").Should().Be("Voice: speak instead of typing");
 		toggle.GetAttribute("aria-pressed").Should().Be("false");
 		component.FindAll(".pdchat-voice-status").Should().BeEmpty();
 		component.Instance.VoiceState.Should().Be(PDChatVoiceState.Off);
 	}
 
+	/// <summary>Verifies that the Voice control sits in the input area beside Send, not in the header.</summary>
+	[Fact]
+	public void The_Voice_control_is_in_the_input_area()
+	{
+		var component = RenderChat(VoiceService());
+
+		component.FindAll(".pdchat-header .pdchat-voice-toggle").Should().BeEmpty();
+		component.FindAll(".chat-input-container .chat-input-accessories .pdchat-voice-toggle").Should().ContainSingle();
+	}
+
+	/// <summary>
+	/// Verifies that the microphone is not asked for until Voice is first turned on: rendering the chat, its input area
+	/// and the agent picker loads no voice module and starts nothing.
+	/// </summary>
+	[Fact]
+	public async Task The_microphone_is_not_requested_until_Voice_is_turned_on()
+	{
+		var module = SetUpVoiceModule();
+		var service = VoiceService();
+		service.Agents = [new("merlin", "Merlin"), new("alice", "Alice")];
+		var component = RenderChat(service);
+		component.Find(".pdchat-voice-toggle");
+		await component.Find(".pdchat-agent-picker select").ChangeAsync(new Microsoft.AspNetCore.Components.ChangeEventArgs { Value = "alice" });
+
+		VoiceModuleImports().Should().BeEmpty();
+		module.Invocations.Should().BeEmpty();
+
+		await component.Find(".pdchat-voice-toggle").ClickAsync(new());
+
+		VoiceModuleImports().Should().ContainSingle();
+		module.Invocations["start"].Should().ContainSingle();
+	}
+
+	private IEnumerable<JSRuntimeInvocation> VoiceModuleImports()
+		=> JSInterop.Invocations["import"].Where(call => VoiceModulePath.Equals(call.Arguments[0]));
+
 	/// <summary>Verifies that a chat whose input is not permitted offers no Voice Mode either.</summary>
 	[Fact]
 	public void Voice_Mode_is_not_offered_where_typing_is_not_permitted()
 	{
-		var service = new FakeChatService { VoiceEndpoints = _voiceEndpoints };
+		var service = VoiceService();
 		((IChatService)service).IsInputPermitted = false;
 
 		RenderChat(service).FindAll(".pdchat-voice-toggle").Should().BeEmpty();
@@ -49,43 +89,158 @@ public void Voice_Mode_is_not_offered_where_typing_is_not_permitted()
 	public async Task Turning_Voice_Mode_on_starts_listening()
 	{
 		var module = SetUpVoiceModule();
-		var component = RenderChat(new FakeChatService { VoiceEndpoints = _voiceEndpoints });
+		var component = RenderChat(VoiceService());
 
 		await component.Find(".pdchat-voice-toggle").ClickAsync(new());
 
 		module.Invocations["start"].Should().ContainSingle().Which.Arguments[0].Should().Be("/voice/listen");
 		component.Instance.VoiceState.Should().Be(PDChatVoiceState.Listening);
 		component.Find(".pdchat-voice-toggle").GetAttribute("aria-pressed").Should().Be("true");
+		component.Find(".pdchat-voice-toggle").GetAttribute("title").Should().Be("Voice: stop listening");
 		component.Find(".pdchat-voice-status").TextContent.Trim().Should().Be("Listening. Ask your question, then pause.");
 	}
 
-	/// <summary>Verifies that a spoken question is sent as the user, as typed text is, and the microphone pauses.</summary>
+	/// <summary>Verifies that the auto-send delay defaults to one second and can be set on a service that does not implement it.</summary>
+	[Fact]
+	public void The_auto_send_delay_defaults_to_one_second()
+	{
+		IChatService service = new FakeChatService();
+
+		service.VoiceAutoSendDelay.Should().Be(TimeSpan.FromMilliseconds(1000));
+
+		service.VoiceAutoSendDelay = TimeSpan.FromMilliseconds(250);
+		service.VoiceAutoSendDelay.Should().Be(TimeSpan.FromMilliseconds(250));
+	}
+
+	/// <summary>Verifies that recognised words are dictated into the text box, and nothing is sent as they arrive.</summary>
 	[Fact]
-	public async Task A_spoken_question_is_sent_like_a_typed_one()
+	public async Task Dictated_words_fill_the_text_box()
+	{
+		SetUpVoiceModule();
+		var service = VoiceService(TimeSpan.FromMinutes(10));
+		var component = await RenderListeningAsync(service);
+
+		await component.InvokeAsync(() => component.Instance.OnVoiceWord("Is"));
+		await component.InvokeAsync(() => component.Instance.OnVoiceWord("MS-26473"));
+		await component.InvokeAsync(() => component.Instance.OnVoiceWord("done?"));
+
+		component.Find("textarea").GetAttribute("value").Should().Be("Is MS-26473 done?");
+		service.Sent.Should().BeEmpty();
+	}
+
+	/// <summary>Verifies that the pause does not repeat words already dictated, and a host that reports only pauses still fills the box.</summary>
+	[Fact]
+	public async Task A_pause_adds_only_what_was_not_dictated()
+	{
+		SetUpVoiceModule();
+		var component = await RenderListeningAsync(VoiceService(TimeSpan.FromMinutes(10)));
+
+		await SayAsync(component, "Is", "it", "done?");
+		await component.InvokeAsync(() => component.Instance.OnVoiceTurn("And the other one?"));
+
+		component.Find("textarea").GetAttribute("value").Should().Be("Is it done? And the other one?");
+	}
+
+	/// <summary>Verifies that after a pause, with the text box not focused, the text is sent as the user once the delay has passed.</summary>
+	[Fact]
+	public async Task Dictation_is_sent_after_the_delay_when_the_text_box_is_not_focused()
 	{
 		var module = SetUpVoiceModule();
-		var service = new FakeChatService { VoiceEndpoints = _voiceEndpoints };
-		var component = RenderChat(service);
-		await component.Find(".pdchat-voice-toggle").ClickAsync(new());
+		var service = VoiceService(TimeSpan.FromMilliseconds(150));
+		var component = await RenderListeningAsync(service);
 
-		await component.InvokeAsync(() => component.Instance.OnVoiceTurn("Is MS-26473 done?"));
+		await SayAsync(component, "Is", "it", "done?");
+		service.Sent.Should().BeEmpty("the delay has not passed");
 
-		var sent = service.Sent.Should().ContainSingle().Subject;
-		sent.Message.Should().Be("Is MS-26473 done?");
+		component.WaitForAssertion(() => service.Sent.Should().ContainSingle(), Patience);
+		var sent = service.Sent[0];
+		sent.Message.Should().Be("Is it done?");
 		sent.Sender.Should().BeSameAs(_user);
 		module.Invocations["pause"].Should().ContainSingle().Which.Arguments[0].Should().Be(true);
+		component.WaitForAssertion(() => component.Find("textarea").GetAttribute("value").Should().BeNullOrEmpty(), Patience);
 		component.Instance.VoiceState.Should().Be(PDChatVoiceState.Thinking);
 	}
 
+	/// <summary>Verifies that while the user is editing the text box, a pause never sends; the user presses Send.</summary>
+	[Fact]
+	public async Task Dictation_is_never_auto_sent_while_the_text_box_has_focus()
+	{
+		var module = SetUpVoiceModule();
+		var service = VoiceService();
+		var component = await RenderListeningAsync(service);
+		await component.Find("textarea").FocusAsync(new FocusEventArgs());
+
+		await SayAsync(component, "Is", "it", "done?");
+		await Task.Delay(_settle, Xunit.TestContext.Current.CancellationToken);
+
+		service.Sent.Should().BeEmpty();
+		component.Find(".pdchat-voice-status").TextContent.Trim().Should().Be("Listening. You are editing, so press Send when ready.");
+
+		await component.Find(".chat-input-container > button").ClickAsync(new MouseEventArgs());
+
+		service.Sent.Should().ContainSingle().Which.Message.Should().Be("Is it done?");
+		module.Invocations["pause"].Should().ContainSingle().Which.Arguments[0].Should().Be(true);
+		component.Instance.VoiceState.Should().Be(PDChatVoiceState.Thinking);
+	}
+
+	/// <summary>Verifies that focusing the text box while a send is pending cancels it.</summary>
+	[Fact]
+	public async Task Focusing_the_text_box_cancels_a_pending_send()
+	{
+		SetUpVoiceModule();
+		var service = VoiceService(TimeSpan.FromMilliseconds(200));
+		var component = await RenderListeningAsync(service);
+
+		await SayAsync(component, "Is", "it", "done?");
+		await component.Find("textarea").FocusAsync(new FocusEventArgs());
+		await component.Find("textarea").BlurAsync(new FocusEventArgs());
+		await Task.Delay(_settle, Xunit.TestContext.Current.CancellationToken);
+
+		service.Sent.Should().BeEmpty();
+	}
+
+	/// <summary>Verifies that speaking again before the delay has passed cancels the pending send until the next pause.</summary>
+	[Fact]
+	public async Task Speaking_again_cancels_a_pending_send()
+	{
+		SetUpVoiceModule();
+		var service = VoiceService(TimeSpan.FromMilliseconds(200));
+		var component = await RenderListeningAsync(service);
+
+		await SayAsync(component, "Is", "it");
+		await component.InvokeAsync(() => component.Instance.OnVoiceWord("done?"));
+		await Task.Delay(_settle, Xunit.TestContext.Current.CancellationToken);
+		service.Sent.Should().BeEmpty();
+
+		await component.InvokeAsync(() => component.Instance.OnVoiceTurn("done?"));
+
+		component.WaitForAssertion(() => service.Sent.Should().ContainSingle().Which.Message.Should().Be("Is it done?"), Patience);
+	}
+
+	/// <summary>Verifies that turning Voice Mode off cancels a pending send.</summary>
+	[Fact]
+	public async Task Turning_Voice_Mode_off_cancels_a_pending_send()
+	{
+		SetUpVoiceModule();
+		var service = VoiceService(TimeSpan.FromMilliseconds(200));
+		var component = await RenderListeningAsync(service);
+
+		await SayAsync(component, "Is", "it", "done?");
+		await component.Find(".pdchat-voice-toggle").ClickAsync(new());
+		await Task.Delay(_settle, Xunit.TestContext.Current.CancellationToken);
+
+		service.Sent.Should().BeEmpty();
+		component.Find("textarea").GetAttribute("value").Should().Be("Is it done?", "dictation stays for the user to send or edit");
+	}
+
 	/// <summary>Verifies that only the finished answer is read aloud, as plain text, and listening then resumes.</summary>
 	[Fact]
 	public async Task The_finished_answer_is_spoken_and_listening_resumes()
 	{
 		var module = SetUpVoiceModule();
-		var service = new FakeChatService { VoiceEndpoints = _voiceEndpoints };
-		var component = RenderChat(service);
-		await component.Find(".pdchat-voice-toggle").ClickAsync(new());
-		await component.InvokeAsync(() => component.Instance.OnVoiceTurn("Is it done?"));
+		var service = VoiceService();
+		var component = await RenderListeningAsync(service);
+		await AskAsync(component, service, "Is it done?");
 
 		var typing = Message("Looking it up", MessageType.Typing);
 		await component.InvokeAsync(() => service.Receive(typing));
@@ -111,10 +266,9 @@ public async Task The_finished_answer_is_spoken_and_listening_resumes()
 	public async Task Only_the_first_reply_to_a_spoken_question_is_spoken()
 	{
 		var module = SetUpVoiceModule();
-		var service = new FakeChatService { VoiceEndpoints = _voiceEndpoints };
-		var component = RenderChat(service);
-		await component.Find(".pdchat-voice-toggle").ClickAsync(new());
-		await component.InvokeAsync(() => component.Instance.OnVoiceTurn("Is it done?"));
+		var service = VoiceService();
+		var component = await RenderListeningAsync(service);
+		await AskAsync(component, service, "Is it done?");
 
 		await component.InvokeAsync(() => service.Receive(Message("Yes.")));
 		await component.InvokeAsync(() => service.Receive(Message("An unrelated notification")));
@@ -127,7 +281,7 @@ public async Task Only_the_first_reply_to_a_spoken_question_is_spoken()
 	public async Task With_Voice_Mode_off_nothing_is_spoken()
 	{
 		var module = SetUpVoiceModule();
-		var service = new FakeChatService { VoiceEndpoints = _voiceEndpoints };
+		var service = VoiceService();
 		var component = RenderChat(service);
 
 		await component.InvokeAsync(() => service.Receive(Message("An answer")));
@@ -140,8 +294,7 @@ public async Task With_Voice_Mode_off_nothing_is_spoken()
 	public async Task Turning_Voice_Mode_off_stops_it()
 	{
 		var module = SetUpVoiceModule();
-		var component = RenderChat(new FakeChatService { VoiceEndpoints = _voiceEndpoints });
-		await component.Find(".pdchat-voice-toggle").ClickAsync(new());
+		var component = await RenderListeningAsync(VoiceService());
 
 		await component.Find(".pdchat-voice-toggle").ClickAsync(new());
 
@@ -156,7 +309,7 @@ public async Task A_refused_microphone_is_explained()
 	{
 		var module = SetUpVoiceModule();
 		_ = module.SetupVoid("start", _ => true).SetException(new JSException("NotAllowedError"));
-		var component = RenderChat(new FakeChatService { VoiceEndpoints = _voiceEndpoints });
+		var component = RenderChat(VoiceService());
 
 		await component.Find(".pdchat-voice-toggle").ClickAsync(new());
 
@@ -164,6 +317,65 @@ public async Task A_refused_microphone_is_explained()
 		component.Find(".pdchat-voice-status").TextContent.Should().Contain("microphone could not be opened");
 	}
 
+	private static FakeChatService VoiceService(TimeSpan? autoSendDelay = null)
+	{
+		var service = new FakeChatService { VoiceEndpoints = _voiceEndpoints };
+		((IChatService)service).VoiceAutoSendDelay = autoSendDelay ?? TimeSpan.Zero;
+		return service;
+	}
+
+	private async Task<IRenderedComponent<PDChat>> RenderListeningAsync(FakeChatService service)
+	{
+		var component = RenderChat(service);
+		await component.Find(".pdchat-voice-toggle").ClickAsync(new());
+		return component;
+	}
+
+	private static async Task SayAsync(IRenderedComponent<PDChat> component, params string[] words)
+	{
+		foreach (var word in words)
+		{
+			await component.InvokeAsync(() => component.Instance.OnVoiceWord(word));
+		}
+
+		await component.InvokeAsync(() => component.Instance.OnVoiceTurn(string.Join(' ', words)));
+	}
+
+	private static async Task AskAsync(IRenderedComponent<PDChat> component, FakeChatService service, string question)
+	{
+		await SayAsync(component, question.Split(' '));
+		component.WaitForAssertion(() => service.Sent.Should().ContainSingle(), Patience);
+	}
+
+	/// <summary>Verifies that endpoints naming their own module have Voice Mode driven by it, not the standard one.</summary>
+	[Fact]
+	public async Task Simulated_Voice_Mode_uses_its_own_module()
+	{
+		var simulated = PDChatVoiceEndpoints.Simulated;
+		var module = JSInterop.SetupModule(simulated.ModulePath!);
+		module.Mode = JSRuntimeMode.Loose;
+		var service = VoiceService();
+		service.VoiceEndpoints = simulated;
+		var component = RenderChat(service);
+
+		await component.Find(".pdchat-voice-toggle").ClickAsync(new());
+
+		VoiceModuleImports().Should().BeEmpty();
+		module.Invocations["start"].Should().ContainSingle();
+		component.Instance.VoiceState.Should().Be(PDChatVoiceState.Listening);
+	}
+
+	/// <summary>Verifies that the demo service shows Voice Mode and the agent picker with no speech service behind it.</summary>
+	[Fact]
+	public void The_demo_service_offers_simulated_Voice_Mode_and_agents()
+	{
+		using var service = new PanoramicData.Blazor.Services.DumbChatService();
+		IChatService chat = service;
+
+		chat.VoiceEndpoints.Should().Be(PDChatVoiceEndpoints.Simulated);
+		chat.Agents.Should().HaveCountGreaterThan(1);
+	}
+
 	private BunitJSModuleInterop SetUpVoiceModule()
 	{
 		var module = JSInterop.SetupModule(VoiceModulePath);
diff --git a/PanoramicData.Blazor.Test/Components/PDMessagesTests.ChatInput.cs b/PanoramicData.Blazor.Test/Components/PDMessagesTests.ChatInput.cs
new file mode 100644
index 000000000..98e180a49
--- /dev/null
+++ b/PanoramicData.Blazor.Test/Components/PDMessagesTests.ChatInput.cs
@@ -0,0 +1,108 @@
+using AwesomeAssertions;
+using Bunit;
+using Microsoft.AspNetCore.Components;
+using Microsoft.AspNetCore.Components.Web;
+using PanoramicData.Blazor.Interfaces;
+
+namespace PanoramicData.Blazor.Test;
+
+/// <summary>
+/// <see cref="PDMessages"/> as an <see cref="IChatInput"/>: text appended from elsewhere, focus tracking, a virtual
+/// Send, and host controls in the input row.
+/// </summary>
+public partial class PDMessagesTests
+{
+	private const string FocusIdentifier = "Blazor._internal.domWrapper.focus";
+
+	/// <summary>Verifies that appended text joins what was typed with a space and is pushed to the parent.</summary>
+	[Fact]
+	public async Task Appended_text_follows_what_was_typed()
+	{
+		var events = new List<string>();
+		var component = RenderLive(events);
+		await component.InvokeAsync(() => component.Find("textarea").InputAsync(new ChangeEventArgs { Value = "Is" }));
+
+		await component.InvokeAsync(() => component.Instance.AppendAsync(" it done? "));
+		await component.InvokeAsync(() => component.Instance.AppendAsync("  "));
+
+		component.Instance.Text.Should().Be("Is it done?");
+		component.Find("textarea").GetAttribute("value").Should().Be("Is it done?");
+		events.Should().Equal("input:Is it done?");
+	}
+
+	/// <summary>Verifies that the text box reports focus and blur, and loses focus when cleared.</summary>
+	[Fact]
+	public async Task Focus_is_tracked_and_reported()
+	{
+		var reported = new List<bool>();
+		var component = Render<PDMessages>(parameters => parameters
+			.Add(p => p.IsLive, true)
+			.Add(p => p.InputFocusChanged, isFocused => reported.Add(isFocused)));
+
+		await component.Find("textarea").FocusAsync(new FocusEventArgs());
+		component.Instance.IsFocused.Should().BeTrue();
+
+		await component.Find("textarea").BlurAsync(new FocusEventArgs());
+		component.Instance.IsFocused.Should().BeFalse();
+
+		await component.Find("textarea").FocusAsync(new FocusEventArgs());
+		await component.InvokeAsync(component.Instance.ClearInput);
+		component.Instance.IsFocused.Should().BeFalse("the text box was replaced");
+
+		reported.Should().Equal(true, false, true);
+	}
+
+	/// <summary>Verifies that a virtual Send behaves as the button does, and sends nothing when empty.</summary>
+	[Fact]
+	public async Task SendAsync_is_the_same_as_pressing_send()
+	{
+		var events = new List<string>();
+		var component = RenderLive(events);
+
+		await component.InvokeAsync(component.Instance.SendAsync);
+		events.Should().BeEmpty();
+
+		await component.InvokeAsync(() => component.Instance.AppendAsync("spoken"));
+		await component.InvokeAsync(component.Instance.SendAsync);
+
+		events.Should().Equal("input:spoken", "input:spoken", "send");
+	}
+
+	/// <summary>Verifies that host controls are shown between the text box and Send, and not at all when absent.</summary>
+	[Fact]
+	public void Input_accessories_sit_beside_send()
+	{
+		RenderLive([]).FindAll(".chat-input-accessories").Should().BeEmpty();
+
+		var component = Render<PDMessages>(parameters => parameters
+			.Add(p => p.IsLive, true)
+			.Add(p => p.InputAccessories, builder => builder.AddMarkupContent(0, "<button class=\"extra\">Extra</button>")));
+
+		var row = component.Find(".chat-input-container");
+		row.Children.Select(child => child.LocalName).Should().Equal("textarea", "div", "button");
+		row.QuerySelector(".chat-input-accessories .extra").Should().NotBeNull();
+	}
+
+	/// <summary>Verifies that the text box takes focus when shown, unless that is turned off.</summary>
+	[Theory]
+	[InlineData(true)]
+	[InlineData(false)]
+	public async Task The_text_box_takes_focus_only_when_auto_focus_is_on(bool isAutoFocused)
+	{
+		var attached = SignalOn("attachEnterHandler");
+		var component = Render<PDMessages>(parameters => parameters
+			.Add(p => p.IsLive, true)
+			.Add(p => p.IsInputAutoFocused, isAutoFocused));
+		await attached.WaitForCountAsync(1);
+
+		if (isAutoFocused)
+		{
+			component.WaitForAssertion(() => JSInterop.Invocations[FocusIdentifier].Should().ContainSingle(), TimeSpan.FromSeconds(10));
+		}
+		else
+		{
+			await Task.Delay(100, Xunit.TestContext.Current.CancellationToken);
+			JSInterop.Invocations[FocusIdentifier].Should().BeEmpty();
+		}
+	}
+}
diff --git a/PanoramicData.Blazor/Interfaces/ChatServiceDefaultState.cs b/PanoramicData.Blazor/Interfaces/ChatServiceDefaultState.cs
index 6f5d3506c..70da9c6e5 100644
--- a/PanoramicData.Blazor/Interfaces/ChatServiceDefaultState.cs
+++ b/PanoramicData.Blazor/Interfaces/ChatServiceDefaultState.cs
@@ -46,6 +46,10 @@ internal sealed class ChatServiceDefaultState
 
 	public PDChatButtonPosition ToastAnchor { get; set; } = PDChatButtonPosition.BottomRight;
 
+	public TimeSpan VoiceAutoSendDelay { get; set; } = TimeSpan.FromMilliseconds(1000);
+
+	public string? SelectedAgentId { get; set; }
+
 	/// <summary>
 	/// Gets or sets the handlers subscribed to the default <see cref="IChatService.OnConversationMessageReceived"/>.
 	/// They are kept so that subscribing and unsubscribing behave as they would on any event, but a service that
diff --git a/PanoramicData.Blazor/Interfaces/IChatInput.cs b/PanoramicData.Blazor/Interfaces/IChatInput.cs
new file mode 100644
index 000000000..341914aa7
--- /dev/null
+++ b/PanoramicData.Blazor/Interfaces/IChatInput.cs
@@ -0,0 +1,24 @@
+namespace PanoramicData.Blazor.Interfaces;
+
+/// <summary>
+/// The text box a chat message is composed in, whatever wrote the text: the keyboard, dictation, or both.
+/// </summary>
+/// <remarks>
+/// <see cref="PanoramicData.Blazor.PDMessages"/> implements this, and <see cref="PanoramicData.Blazor.PDChat"/>'s Voice
+/// control writes through it, so dictated words land where typed ones do and can be edited before sending.
+/// </remarks>
+public interface IChatInput
+{
+	/// <summary>Gets the text currently in the box.</summary>
+	string Text { get; }
+
+	/// <summary>Gets a value indicating whether the box has focus, meaning the user may be editing it.</summary>
+	bool IsFocused { get; }
+
+	/// <summary>Appends text to the end of the box, separated from what is already there by a space.</summary>
+	/// <param name="text">The text to add.</param>
+	Task AppendAsync(string text);
+
+	/// <summary>Sends the box's text exactly as pressing Send would; does nothing when there is nothing to send.</summary>
+	Task SendAsync();
+}
diff --git a/PanoramicData.Blazor/Interfaces/IChatService.cs b/PanoramicData.Blazor/Interfaces/IChatService.cs
index e108f280a..cbaa41c20 100644
--- a/PanoramicData.Blazor/Interfaces/IChatService.cs
+++ b/PanoramicData.Blazor/Interfaces/IChatService.cs
@@ -94,6 +94,33 @@ bool IsInputPermitted
 	/// </summary>
 	PDChatVoiceEndpoints? VoiceEndpoints => null;
 
+	/// <summary>
+	/// Gets or sets how long after the speaker pauses Voice Mode sends the dictated text, when the user is not
+	/// editing it. Defaults to one second.
+	/// </summary>
+	TimeSpan VoiceAutoSendDelay
+	{
+		get => ChatServiceDefaultState.For(this).VoiceAutoSendDelay;
+		set => ChatServiceDefaultState.For(this).VoiceAutoSendDelay = value;
+	}
+
+	/// <summary>
+	/// Gets the agents the user may choose to talk to, or null (the default) when the host offers no choice.
+	/// A picker is shown in the input area only when there are two or more.
+	/// </summary>
+	IReadOnlyList<PDChatAgentOption>? Agents => null;
+
+	/// <summary>
+	/// Gets or sets the <see cref="PDChatAgentOption.Id"/> of the agent the user is talking to, or null (the default)
+	/// for the host's default. The chat sets this when the user picks an agent; a host that needs to react implements
+	/// the setter.
+	/// </summary>
+	string? SelectedAgentId
+	{
+		get => ChatServiceDefaultState.For(this).SelectedAgentId;
+		set => ChatServiceDefaultState.For(this).SelectedAgentId = value;
+	}
+
 	/// <summary>
 	/// Gets or sets whether the chat should auto-restore when new messages arrive.
 	/// </summary>
diff --git a/PanoramicData.Blazor/Models/PDChatAgentOption.cs b/PanoramicData.Blazor/Models/PDChatAgentOption.cs
new file mode 100644
index 000000000..be0a2b7d0
--- /dev/null
+++ b/PanoramicData.Blazor/Models/PDChatAgentOption.cs
@@ -0,0 +1,11 @@
+namespace PanoramicData.Blazor.Models;
+
+/// <summary>
+/// One of the agents a host offers in <see cref="PanoramicData.Blazor.PDChat"/>'s input area, for the user to choose
+/// who they are talking to.
+/// </summary>
+/// <param name="Id">The identifier the host recognises, stored in <see cref="Interfaces.IChatService.SelectedAgentId"/>.</param>
+/// <param name="Name">The name shown in the picker.</param>
+/// <param name="Description">An optional description, shown as the option's tooltip.</param>
+/// <param name="IconUrl">An optional icon, shown beside the picker while this agent is selected.</param>
+public sealed record PDChatAgentOption(string Id, string Name, string? Description = null, string? IconUrl = null);
diff --git a/PanoramicData.Blazor/Models/PDChatVoiceEndpoints.cs b/PanoramicData.Blazor/Models/PDChatVoiceEndpoints.cs
index 3b1e36fcd..4e5bf24be 100644
--- a/PanoramicData.Blazor/Models/PDChatVoiceEndpoints.cs
+++ b/PanoramicData.Blazor/Models/PDChatVoiceEndpoints.cs
@@ -12,5 +12,16 @@ namespace PanoramicData.Blazor.Models;
 /// Receives one JSON message, <c>{"text":...}</c>, and answers with 24 kHz mono float32 audio as binary messages,
 /// then <c>{"type":"done"}</c>.
 /// </param>
+/// <param name="ModulePath">
+/// An optional replacement for the browser module that drives the microphone and plays answers, exporting the same
+/// <c>start</c>, <c>pause</c>, <c>speak</c> and <c>stop</c> functions; null uses the standard one.
+/// </param>
 /// <remarks>Relative URLs are resolved against the page. Speech is processed wherever the host's endpoints send it.</remarks>
-public sealed record PDChatVoiceEndpoints(string ListenUrl, string SpeakUrl);
+public sealed record PDChatVoiceEndpoints(string ListenUrl, string SpeakUrl, string? ModulePath = null)
+{
+	/// <summary>
+	/// Voice Mode with no speech service, for demos: it hears that the user is talking but makes the words up, and
+	/// answers in the browser's own voice. No audio leaves the browser.
+	/// </summary>
+	public static PDChatVoiceEndpoints Simulated { get; } = new("simulated", "simulated", "./_content/PanoramicData.Blazor/js/pdchat-voice-simulated.js");
+}
diff --git a/PanoramicData.Blazor/PDChat.Agents.cs b/PanoramicData.Blazor/PDChat.Agents.cs
new file mode 100644
index 000000000..bb40aeafb
--- /dev/null
+++ b/PanoramicData.Blazor/PDChat.Agents.cs
@@ -0,0 +1,25 @@
+namespace PanoramicData.Blazor;
+
+/// <summary>
+/// PDChat: the agent picker in the input area, offered when the chat service lists two or more
+/// <see cref="IChatService.Agents"/>.
+/// </summary>
+public partial class PDChat
+{
+	private bool IsAgentPickerOffered => ChatService.Agents is { Count: > 1 };
+
+	// Null or unknown means the host's default, which the picker shows as its first agent.
+	private PDChatAgentOption? SelectedAgent => ChatService.Agents?.FirstOrDefault(agent => agent.Id == ChatService.SelectedAgentId)
+		?? (ChatService.Agents is { Count: > 0 } agents ? agents[0] : null);
+
+	private RenderFragment? InputAccessories => IsVoiceModeOffered || IsAgentPickerOffered ? InputAccessoriesContent : null;
+
+	private void OnAgentSelected(ChangeEventArgs args)
+	{
+		var id = args.Value?.ToString();
+		if (ChatService.Agents?.Any(agent => agent.Id == id) == true)
+		{
+			ChatService.SelectedAgentId = id;
+		}
+	}
+}
diff --git a/PanoramicData.Blazor/PDChat.Voice.cs b/PanoramicData.Blazor/PDChat.Voice.cs
index b87374d49..106411db7 100644
--- a/PanoramicData.Blazor/PDChat.Voice.cs
+++ b/PanoramicData.Blazor/PDChat.Voice.cs
@@ -22,12 +22,14 @@ public enum PDChatVoiceState
 }
 
 /// <summary>
-/// Voice Mode for <see cref="PDChat"/>: the user speaks a question, pauses, and hears the answer. Off by default, and
+/// Voice Mode for <see cref="PDChat"/>: the user dictates into the text box, and hears the answer. Off by default, and
 /// offered only when the chat service supplies <see cref="IChatService.VoiceEndpoints"/>.
 /// </summary>
 /// <remarks>
-/// A spoken question goes through the same path as a typed one, so the question and the written answer are both in
-/// the transcript. Only the first finished reply to a spoken question is read aloud.
+/// Recognised words are appended to the text box, where they can be edited. When the speaker pauses and the box does
+/// not have focus, the text is sent after <see cref="IChatService.VoiceAutoSendDelay"/> as if Send had been pressed;
+/// while the user is editing, they press Send themselves. The first finished reply to a message sent while Voice Mode
+/// is listening is read aloud.
 /// </remarks>
 public partial class PDChat
 {
@@ -36,7 +38,8 @@ public partial class PDChat
 	private IJSObjectReference? _voiceModule;
 	private DotNetObjectReference<PDChat>? _voiceReference;
 	private bool _isAwaitingSpokenAnswer;
-	private string _voiceHeard = string.Empty;
+	private bool _hasDictatedSinceTurn;
+	private CancellationTokenSource? _autoSendCancellation;
 
 	/// <summary>Gets where Voice Mode is in a spoken exchange.</summary>
 	public PDChatVoiceState VoiceState { get; private set; } = PDChatVoiceState.Off;
@@ -44,22 +47,27 @@ public partial class PDChat
 	/// <summary>Gets the last problem Voice Mode reported, shown in place of its status.</summary>
 	public string? VoiceError { get; private set; }
 
+	// Dictation goes through the same text box as typing, via its IChatInput members.
+	private PDMessages? VoiceInput => MessagesComponent;
+
 	private bool IsVoiceModeOffered => ChatService.VoiceEndpoints is not null && ChatService.IsInputPermitted;
 
 	private bool IsVoiceModeOn => VoiceState != PDChatVoiceState.Off;
 
 	private string VoiceButtonTitle => IsVoiceModeOn
-		? "Turn Voice Mode off"
-		: "Turn Voice Mode on: ask out loud and hear the answer";
+		? "Voice: stop listening"
+		: "Voice: speak instead of typing";
 
 	private string VoiceStatusCssClass => $"pdchat-voice-status pdchat-voice-{VoiceState.ToString().ToLowerInvariant()}" + (VoiceError is null ? string.Empty : " pdchat-voice-error");
 
 	private string VoiceStatusText => VoiceError ?? VoiceState switch
 	{
 		PDChatVoiceState.Starting => "Opening the microphone…",
-		PDChatVoiceState.Listening => _voiceHeard.Length > 0 ? _voiceHeard : "Listening. Ask your question, then pause.",
+		PDChatVoiceState.Listening => VoiceInput?.IsFocused == true
+			? "Listening. You are editing, so press Send when ready."
+			: "Listening. Ask your question, then pause.",
 		PDChatVoiceState.Thinking => "Thinking…",
-		PDChatVoiceState.Speaking => "Speaking. Turn Voice Mode off to stop.",
+		PDChatVoiceState.Speaking => "Speaking. Turn Voice off to stop.",
 		_ => string.Empty,
 	};
 
@@ -80,7 +88,7 @@ private async Task ToggleVoiceModeAsync()
 		VoiceState = PDChatVoiceState.Starting;
 		try
 		{
-			_voiceModule ??= await JSRuntime.InvokeAsync<IJSObjectReference>("import", _voiceModulePath);
+			_voiceModule ??= await JSRuntime.InvokeAsync<IJSObjectReference>("import", endpoints.ModulePath ?? _voiceModulePath);
 			_voiceReference ??= DotNetObjectReference.Create(this);
 			await _voiceModule.InvokeVoidAsync("start", endpoints.ListenUrl, _voiceReference);
 			VoiceState = PDChatVoiceState.Listening;
@@ -94,44 +102,61 @@ private async Task ToggleVoiceModeAsync()
 
 	private async Task StopVoiceModeAsync()
 	{
+		CancelAutoSend();
 		VoiceState = PDChatVoiceState.Off;
 		_isAwaitingSpokenAnswer = false;
-		_voiceHeard = string.Empty;
+		_hasDictatedSinceTurn = false;
 		if (_voiceModule is not null)
 		{
 			await _voiceModule.InvokeVoidAsync("stop");
 		}
 	}
 
-	/// <summary>Called by the voice module as words are recognised.</summary>
+	/// <summary>Called by the voice module as words are recognised; appends them to the text box.</summary>
 	/// <param name="text">The word just heard.</param>
 	[JSInvokable]
-	public Task OnVoiceWord(string text)
+	public Task OnVoiceWord(string text) => InvokeAsync(async () =>
 	{
-		_voiceHeard = $"{_voiceHeard} {text}".Trim();
-		return InvokeAsync(StateHasChanged);
-	}
+		if (VoiceState != PDChatVoiceState.Listening || VoiceInput is not { } input)
+		{
+			return;
+		}
 
-	/// <summary>Called by the voice module when the speaker has finished; sends what they said as a question.</summary>
-	/// <param name="text">The whole question.</param>
+		// The speaker has carried on, so the pause that scheduled a send is over.
+		CancelAutoSend();
+		_hasDictatedSinceTurn = true;
+		await input.AppendAsync(text);
+	});
+
+	/// <summary>
+	/// Called by the voice module when the speaker pauses. Unless the user is editing the text box, its text is sent
+	/// after <see cref="IChatService.VoiceAutoSendDelay"/>.
+	/// </summary>
+	/// <param name="text">Everything said since the last pause.</param>
 	[JSInvokable]
-	public async Task OnVoiceTurn(string text)
+	public Task OnVoiceTurn(string text) => InvokeAsync(async () =>
 	{
-		if (VoiceState != PDChatVoiceState.Listening || string.IsNullOrWhiteSpace(text))
+		if (VoiceState != PDChatVoiceState.Listening || VoiceInput is not { } input)
 		{
 			return;
 		}
 
-		_voiceHeard = string.Empty;
-		_currentInput = text;
-		VoiceState = PDChatVoiceState.Thinking;
-		_isAwaitingSpokenAnswer = true;
+		CancelAutoSend();
 
-		// Half duplex: while Merlin thinks and speaks, the microphone sends nothing, so it never hears itself.
-		await (_voiceModule?.InvokeVoidAsync("pause", true) ?? ValueTask.CompletedTask);
-		await SendCurrentMessageAsync();
-		await InvokeAsync(StateHasChanged);
-	}
+		// A host that reports no words still has its pause recorded.
+		if (!_hasDictatedSinceTurn)
+		{
+			await input.AppendAsync(text);
+		}
+
+		_hasDictatedSinceTurn = false;
+		if (!input.IsFocused && !string.IsNullOrWhiteSpace(input.Text))
+		{
+			ScheduleAutoSend();
+		}
+
+		StateHasChanged();
+	});
 
 	/// <summary>Called by the voice module when speech recognition reports a problem.</summary>
 	/// <param name="text">What went wrong, for the user.</param>
@@ -146,12 +171,85 @@ public Task OnVoiceError(string text)
 	[JSInvokable]
 	public Task OnVoiceClosed()
 	{
+		CancelAutoSend();
 		VoiceState = PDChatVoiceState.Off;
 		_isAwaitingSpokenAnswer = false;
 		VoiceError ??= "Voice Mode stopped: the connection closed.";
 		return InvokeAsync(StateHasChanged);
 	}
 
+	private Task OnInputFocusChangedAsync(bool isFocused)
+	{
+		// The user is editing, so whatever was dictated waits for them to press Send.
+		if (isFocused)
+		{
+			CancelAutoSend();
+		}
+
+		return Task.CompletedTask;
+	}
+
+	private void ScheduleAutoSend()
+	{
+		var cancellation = new CancellationTokenSource();
+		_autoSendCancellation = cancellation;
+		_ = AutoSendAfterDelayAsync(cancellation.Token);
+	}
+
+	private void CancelAutoSend()
+	{
+		if (_autoSendCancellation is null)
+		{
+			return;
+		}
+
+		_autoSendCancellation.Cancel();
+		_autoSendCancellation.Dispose();
+		_autoSendCancellation = null;
+	}
+
+	private async Task AutoSendAfterDelayAsync(CancellationToken cancellationToken)
+	{
+		try
+		{
+			var delay = ChatService.VoiceAutoSendDelay;
+			await Task.Delay(delay < TimeSpan.Zero ? TimeSpan.Zero : delay, cancellationToken);
+			await InvokeAsync(async () =>
+			{
+				if (cancellationToken.IsCancellationRequested || VoiceState != PDChatVoiceState.Listening
+					|| VoiceInput is not { IsFocused: false } input)
+				{
+					return;
+				}
+
+				await input.SendAsync();
+			});
+		}
+		catch (Exception ex) when (ex is JSDisconnectedException or OperationCanceledException or ObjectDisposedException)
+		{
+			// Cancelled by the speaker or the user, or the circuit is going away.
+		}
+	}
+
+	/// <summary>
+	/// Marks a message about to be sent while listening as a spoken exchange: the microphone pauses and the reply is read aloud.
+	/// </summary>
+	private async Task BeginSpokenExchangeAsync()
+	{
+		if (VoiceState != PDChatVoiceState.Listening)
+		{
+			return;
+		}
+
+		CancelAutoSend();
+		_hasDictatedSinceTurn = false;
+		VoiceState = PDChatVoiceState.Thinking;
+		_isAwaitingSpokenAnswer = true;
+
+		// Half duplex: while Merlin thinks and speaks, the microphone sends nothing, so it never hears itself.
+		await (_voiceModule?.InvokeVoidAsync("pause", true) ?? ValueTask.CompletedTask);
+	}
+
 	/// <summary>Reads the first finished reply to a spoken question aloud, then listens again.</summary>
 	private async Task SpeakAnswerIfAwaitedAsync(ChatMessage message)
 	{
@@ -192,6 +290,7 @@ private static string ToSpeakableText(ChatMessage message)
 
 	private async ValueTask DisposeVoiceAsync()
 	{
+		CancelAutoSend();
 		if (_voiceModule is not null)
 		{
 			try
diff --git a/PanoramicData.Blazor/PDChat.razor b/PanoramicData.Blazor/PDChat.razor
index 0ab5fbde1..55244cee2 100644
--- a/PanoramicData.Blazor/PDChat.razor
+++ b/PanoramicData.Blazor/PDChat.razor
@@ -84,15 +84,6 @@
 							<span>🗑️</span>
 						</button>
 					}
-					@if (IsVoiceModeOffered)
-					{
-						<button class="pdchat-header-btn pdchat-voice-toggle@(IsVoiceModeOn ? " active" : string.Empty)"
-								@onclick="ToggleVoiceModeAsync"
-								title="@VoiceButtonTitle"
-								aria-pressed="@(IsVoiceModeOn ? "true" : "false")">
-							<span>🎙️ Voice</span>
-						</button>
-					}
 					<button class="pdchat-header-btn" @onclick="ToggleMuteAsync" title="@(_isMuted ? "Unmute" : "Mute")">
 						<span>@(_isMuted ? "🔇" : "🔊")</span>
 					</button>
@@ -208,6 +199,9 @@
 													IsInputPermitted="@ChatService.IsInputPermitted"
 													InputDisabledMessage="@ChatService.InputDisabledMessage"
 													OnSendClicked="SendCurrentMessageAsync"
+													InputAccessories="InputAccessories"
+													InputFocusChanged="OnInputFocusChangedAsync"
+													IsInputAutoFocused="@(!IsVoiceModeOn)"
 													UserIconSelector="UserIconSelector"
 													UseFullWidthMessages="@ChatService.UseFullWidthMessages"
 													MessageMetadataDisplayMode="@ChatService.MessageMetadataDisplayMode"
@@ -255,6 +249,9 @@
 										IsInputPermitted="@ChatService.IsInputPermitted"
 										InputDisabledMessage="@ChatService.InputDisabledMessage"
 										OnSendClicked="SendCurrentMessageAsync"
+										InputAccessories="InputAccessories"
+										InputFocusChanged="OnInputFocusChangedAsync"
+										IsInputAutoFocused="@(!IsVoiceModeOn)"
 										UserIconSelector="UserIconSelector"
 										UseFullWidthMessages="@ChatService.UseFullWidthMessages"
 										MessageMetadataDisplayMode="@ChatService.MessageMetadataDisplayMode"
@@ -276,6 +273,9 @@
 								IsInputPermitted="@ChatService.IsInputPermitted"
 								InputDisabledMessage="@ChatService.InputDisabledMessage"
 								OnSendClicked="SendCurrentMessageAsync"
+								InputAccessories="InputAccessories"
+								InputFocusChanged="OnInputFocusChangedAsync"
+								IsInputAutoFocused="@(!IsVoiceModeOn)"
 								UserIconSelector="UserIconSelector"
 								UseFullWidthMessages="@ChatService.UseFullWidthMessages"
 								MessageMetadataDisplayMode="@ChatService.MessageMetadataDisplayMode"
@@ -289,3 +289,36 @@
 	}
 </div>
 </CascadingValue>
+
+@code {
+	private RenderFragment InputAccessoriesContent => @<text>
+		@if (IsAgentPickerOffered)
+		{
+			<div class="pdchat-agent-picker">
+				@if (SelectedAgent?.IconUrl is { } iconUrl)
+				{
+					<img class="pdchat-agent-icon" src="@iconUrl" alt="" />
+				}
+				<select class="form-select form-select-sm"
+						title="Who you are talking to"
+						aria-label="Who you are talking to"
+						@onchange="OnAgentSelected">
+					@foreach (var agent in ChatService.Agents!)
+					{
+						<option value="@agent.Id" title="@agent.Description" selected="@(agent.Id == SelectedAgent?.Id)">@agent.Name</option>
+					}
+				</select>
+			</div>
+		}
+		@if (IsVoiceModeOffered)
+		{
+			<button type="button"
+					class="btn btn-sm btn-outline-secondary pdchat-voice-toggle@(IsVoiceModeOn ? " active" : string.Empty)"
+					@onclick="ToggleVoiceModeAsync"
+					title="@VoiceButtonTitle"
+					aria-pressed="@(IsVoiceModeOn ? "true" : "false")">
+				<span>🎙️ Voice</span>
+			</button>
+		}
+	</text>;
+}
\ No newline at end of file
diff --git a/PanoramicData.Blazor/PDChat.razor.cs b/PanoramicData.Blazor/PDChat.razor.cs
index 9af92c3d9..d4f623735 100644
--- a/PanoramicData.Blazor/PDChat.razor.cs
+++ b/PanoramicData.Blazor/PDChat.razor.cs
@@ -537,6 +537,9 @@ private async Task SendCurrentMessageAsync()
 			Timestamp = DateTime.UtcNow
 		};
 
+		// Before sending, so a reply that arrives at once is still the one spoken.
+		await BeginSpokenExchangeAsync();
+
 		// Fire it off
 		ChatService.SendMessage(message);
 
diff --git a/PanoramicData.Blazor/PDChat.razor.css b/PanoramicData.Blazor/PDChat.razor.css
index 71610bde4..79c330574 100644
--- a/PanoramicData.Blazor/PDChat.razor.css
+++ b/PanoramicData.Blazor/PDChat.razor.css
@@ -543,18 +543,34 @@ body:has(.pdchat-container.dock-fullscreen) {
 	outline-offset: 1px;
 }
 
-/* Voice Mode: the switch carries a word as well as an icon, so it says what it does. */
+/* Input-area controls: the Voice switch carries a word as well as an icon, so it says what it does. */
 .pdchat-voice-toggle {
-	font-size: 14px;
-	min-width: auto;
 	white-space: nowrap;
 }
 
 .pdchat-voice-toggle.active {
-	background: rgba(255,255,255,0.25);
-	box-shadow: inset 0 0 0 1px rgba(255,255,255,0.6);
+	color: var(--pd-chat-bg, #fff);
+	background: #dc3545;
+	border-color: #dc3545;
 }
 
+.pdchat-agent-picker {
+	display: flex;
+	align-items: center;
+	gap: 4px;
+	min-width: 0;
+}
+
+.pdchat-agent-picker select {
+	min-width: 0;
+}
+
+.pdchat-agent-icon {
+	width: 20px;
+	height: 20px;
+	flex-shrink: 0;
+	border-radius: 50%;
+}
 .pdchat-voice-status {
 	padding: 6px 12px;
 	font-size: 13px;
diff --git a/PanoramicData.Blazor/PDMessages.Interop.cs b/PanoramicData.Blazor/PDMessages.Interop.cs
index ba61599da..21cf841c7 100644
--- a/PanoramicData.Blazor/PDMessages.Interop.cs
+++ b/PanoramicData.Blazor/PDMessages.Interop.cs
@@ -38,7 +38,10 @@ await JSRuntime.InvokeAsync<IJSObjectReference>(
 				_dotNetRef ??= DotNetObjectReference.Create(this);
 				await _module.InvokeVoidAsync("attachEnterHandler", InputRef, _dotNetRef);
 				_enterHandlerAttached = true;
-				await InputRef.FocusAsync();
+				if (IsInputAutoFocused)
+				{
+					await InputRef.FocusAsync();
+				}
 			}
 			catch (Exception)
 			{
diff --git a/PanoramicData.Blazor/PDMessages.razor b/PanoramicData.Blazor/PDMessages.razor
index ff112e3fa..030ca2291 100644
--- a/PanoramicData.Blazor/PDMessages.razor
+++ b/PanoramicData.Blazor/PDMessages.razor
@@ -25,9 +25,15 @@
 				@ref="InputRef"
 				value="@_localInput"
 				@oninput="OnInputChanged"
+				@onfocus="() => SetInputFocusedAsync(true)"
+				@onblur="() => SetInputFocusedAsync(false)"
 				placeholder="Type a message..."
 				rows="3"
 				disabled="@(!IsLive)"></textarea>
+			@if (InputAccessories is not null)
+			{
+				<div class="chat-input-accessories">@InputAccessories</div>
+			}
 			<button class="btn btn-sm btn-secondary" @onclick="OnSendClickedInternal" disabled="@(!CanSendLocal)">Send</button>
 		</div>
 	}
diff --git a/PanoramicData.Blazor/PDMessages.razor.cs b/PanoramicData.Blazor/PDMessages.razor.cs
index 9dc6366f5..3450cb2bf 100644
--- a/PanoramicData.Blazor/PDMessages.razor.cs
+++ b/PanoramicData.Blazor/PDMessages.razor.cs
@@ -3,7 +3,7 @@ namespace PanoramicData.Blazor;
 /// <summary>
 /// A Blazor component that displays a list of chat messages with a send input area.
 /// </summary>
-public partial class PDMessages
+public partial class PDMessages : IChatInput
 {
 	/// <summary>
 	/// Gets or sets the injected JavaScript runtime.
@@ -99,11 +99,51 @@ public partial class PDMessages
 	/// </summary>
 	internal ElementReference InputRef { get; set; }
 
+	/// <summary>
+	/// Gets or sets optional controls shown in the input row beside the Send button, such as a voice or agent control.
+	/// </summary>
+	[Parameter] public RenderFragment? InputAccessories { get; set; }
+
+	/// <summary>
+	/// An event callback that is invoked when the text box gains (<c>true</c>) or loses (<c>false</c>) focus.
+	/// </summary>
+	[Parameter] public EventCallback<bool> InputFocusChanged { get; set; }
+
+	/// <summary>
+	/// Gets or sets whether the text box takes focus when first shown and after each send. Defaults to true.
+	/// </summary>
+	[Parameter] public bool IsInputAutoFocused { get; set; } = true;
+
 	private string _localInput = string.Empty;
 	private string _inputKey = Guid.NewGuid().ToString();
 
 	private bool CanSendLocal => IsInputPermitted && IsLive && !string.IsNullOrWhiteSpace(_localInput);
 
+	/// <inheritdoc />
+	public string Text => _localInput;
+
+	/// <inheritdoc />
+	public bool IsFocused { get; private set; }
+
+	/// <inheritdoc />
+	public async Task AppendAsync(string text)
+	{
+		if (string.IsNullOrWhiteSpace(text))
+		{
+			return;
+		}
+
+		var addition = text.Trim();
+		_localInput = _localInput.Length == 0 || char.IsWhiteSpace(_localInput[^1])
+			? _localInput + addition
+			: $"{_localInput} {addition}";
+		await CurrentInputChanged.InvokeAsync(_localInput);
+		StateHasChanged();
+	}
+
+	/// <inheritdoc />
+	public Task SendAsync() => OnSendClickedInternal();
+
 	/// <summary>
 	/// Clears the textarea. Called by the parent after a message is sent.
 	/// </summary>
@@ -111,10 +151,19 @@ public void ClearInput()
 	{
 		_localInput = string.Empty;
 		_inputKey = Guid.NewGuid().ToString();
+
+		// The text box is replaced, and a removed element does not reliably report losing focus.
+		IsFocused = false;
 		ResetEnterHandler();
 		StateHasChanged();
 	}
 
+	private async Task SetInputFocusedAsync(bool isFocused)
+	{
+		IsFocused = isFocused;
+		await InputFocusChanged.InvokeAsync(isFocused);
+	}
+
 	/// <summary>
 	/// Called from JavaScript when Enter is pressed in the textarea.
 	/// </summary>
diff --git a/PanoramicData.Blazor/PDMessages.razor.css b/PanoramicData.Blazor/PDMessages.razor.css
index 103468262..eb5d65e56 100644
--- a/PanoramicData.Blazor/PDMessages.razor.css
+++ b/PanoramicData.Blazor/PDMessages.razor.css
@@ -113,6 +113,17 @@
 	flex-shrink: 0;
 }
 
+/* Host-supplied controls (voice, agent) stacked beside Send. */
+.chat-input-accessories {
+	display: flex;
+	flex-direction: column;
+	align-items: stretch;
+	gap: 4px;
+	flex-shrink: 0;
+	min-width: 0;
+	max-width: 40%;
+}
+
 /* Message shown in place of the input when input is not permitted (IsInputPermitted = false).
    Theme-aware via the --pd-chat-* variables. */
 .chat-input-disabled {
diff --git a/PanoramicData.Blazor/Services/DumbChatService.Voice.cs b/PanoramicData.Blazor/Services/DumbChatService.Voice.cs
new file mode 100644
index 000000000..50116c496
--- /dev/null
+++ b/PanoramicData.Blazor/Services/DumbChatService.Voice.cs
@@ -0,0 +1,17 @@
+namespace PanoramicData.Blazor.Services;
+
+/// <summary>
+/// The Voice Mode and agent picker of <see cref="DumbChatService"/>, so a demo shows both without a speech service.
+/// </summary>
+public partial class DumbChatService
+{
+	/// <summary>Gets or sets Voice Mode's endpoints; simulated by default, and null hides Voice Mode.</summary>
+	public PDChatVoiceEndpoints? VoiceEndpoints { get; set; } = PDChatVoiceEndpoints.Simulated;
+
+	/// <summary>Gets the agents offered in the input area.</summary>
+	public IReadOnlyList<PDChatAgentOption>? Agents { get; } =
+	[
+		new("dumbbot", "DumbBot", "Answers by keyword, and not very well."),
+		new("parrot", "Parrot", "Exactly as helpful as DumbBot, with more feathers."),
+	];
+}
diff --git a/PanoramicData.Blazor/wwwroot/js/pdchat-voice-simulated.js b/PanoramicData.Blazor/wwwroot/js/pdchat-voice-simulated.js
new file mode 100644
index 000000000..5557b86df
--- /dev/null
+++ b/PanoramicData.Blazor/wwwroot/js/pdchat-voice-simulated.js
@@ -0,0 +1,129 @@
+// PDChat Voice Mode, simulated: hears THAT you are talking, never WHAT, and makes the words up.
+// Same exports as pdchat-voice.js. Audio never leaves the browser.
+
+const PHRASES = [
+	"I know this is not what you are actually saying, but to use real voice recognition you need to hook in a streaming speech service.",
+	"blah blah blah blah blah blah",
+	"This is a simulated transcript, and none of your words were sent anywhere.",
+	"Pretend I just asked something really clever.",
+	"Supply VoiceEndpoints from your chat service to hear the real thing.",
+	"Testing, testing, one two three. Is this thing on?",
+];
+
+const LOUD = 0.02;
+const WORD_MS = 220;
+const PAUSE_MS = 700;
+
+let listening = null;
+let phraseIndex = 0;
+let wordIndex = 0;
+
+function nextWord() {
+	const words = PHRASES[phraseIndex].split(" ");
+	const word = words[wordIndex];
+	wordIndex++;
+	if (wordIndex >= words.length) {
+		wordIndex = 0;
+		phraseIndex = (phraseIndex + 1) % PHRASES.length;
+	}
+	return word;
+}
+
+function level(analyser, samples) {
+	analyser.getFloatTimeDomainData(samples);
+	let sum = 0;
+	for (let i = 0; i < samples.length; i++) {
+		sum += samples[i] * samples[i];
+	}
+	return Math.sqrt(sum / samples.length);
+}
+
+function tick(state, dotNet) {
+	if (state.paused) {
+		return;
+	}
+	const now = Date.now();
+	if (level(state.analyser, state.samples) > LOUD) {
+		state.lastLoud = now;
+		if (now - state.lastWord >= WORD_MS) {
+			state.lastWord = now;
+			const word = nextWord();
+			state.heard.push(word);
+			dotNet.invokeMethodAsync("OnVoiceWord", word);
+		}
+	} else if (state.heard.length > 0 && now - state.lastLoud >= PAUSE_MS) {
+		const text = state.heard.join(" ");
+		state.heard = [];
+		dotNet.invokeMethodAsync("OnVoiceTurn", text);
+	}
+}
+
+/** Starts listening. Rejects when the microphone is refused or unavailable. */
+export async function start(listenUrl, dotNet) {
+	stop();
+	const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+	const context = new AudioContext();
+	const analyser = context.createAnalyser();
+	analyser.fftSize = 1024;
+	context.createMediaStreamSource(stream).connect(analyser);
+	const state = {
+		stream,
+		context,
+		analyser,
+		samples: new Float32Array(analyser.fftSize),
+		paused: false,
+		heard: [],
+		lastLoud: 0,
+		lastWord: 0,
+	};
+	state.timer = setInterval(() => tick(state, dotNet), 50);
+	listening = state;
+}
+
+/** While paused nothing is "heard", so the assistant does not hear itself. */
+export function pause(paused) {
+	if (listening) {
+		listening.paused = paused;
+		listening.heard = [];
+	}
+}
+
+/** Stops listening and speaking, and releases the microphone. */
+export function stop() {
+	stopSpeaking();
+	if (!listening) {
+		return;
+	}
+	const state = listening;
+	listening = null;
+	clearInterval(state.timer);
+	state.stream.getTracks().forEach((track) => track.stop());
+	state.context.close();
+}
+
+/** Stops an answer part-way through. */
+export function stopSpeaking() {
+	if (globalThis.speechSynthesis) {
+		globalThis.speechSynthesis.cancel();
+	}
+}
+
+/** Speaks an answer with the browser's own voice, and calls OnVoiceSpoken when it ends. */
+export function speak(speakUrl, text, dotNet) {
+	stopSpeaking();
+	let finished = false;
+	const finish = () => {
+		if (!finished) {
+			finished = true;
+			dotNet.invokeMethodAsync("OnVoiceSpoken");
+		}
+	};
+	if (!globalThis.speechSynthesis) {
+		setTimeout(finish, 60 * text.length);
+		return;
+	}
+	const utterance = new SpeechSynthesisUtterance(text);
+	utterance.onend = finish;
+	utterance.onerror = finish;
+	globalThis.speechSynthesis.speak(utterance);
+}