@@ -10,7 +10,8 @@ import {
 	toast,
 	useMedia,
 } from "@ace/ui";
-import type { Listing, ModelRef } from "@ace/host/protocol";
+import type { Effort, ModelOption, ModelRef } from "@ace/channel/protocol";
+import type { Listing } from "@ace/host/protocol";
 
 import { host } from "./host";
 import { images } from "./images";
@@ -20,6 +21,15 @@ const MODES = [
 	{ id: "ace", name: "Ace", placeholder: "Ask the agent", mention: "ace" },
 ];
 const MENTIONS = [{ name: "ace", avatar: aceAvatar }];
+const EFFORTS: Record<Effort, string> = {
+	off: "Off",
+	minimal: "Minimal",
+	low: "Low",
+	medium: "Medium",
+	high: "High",
+	xhigh: "Extra high",
+	max: "Max",
+};
 const ACE = /(^|\s)@ace\b/i;
 // Channel views remount on navigation; a deliberate mode choice outlives them for this session.
 const chosen = new Map<string, string>();
@@ -31,6 +41,7 @@ type Props = {
 	chat: number;
 	user: string;
 	current?: ModelRef;
+	currentEffort?: Effort;
 	busy: boolean;
 	ready: boolean;
 	draft?: string;
@@ -41,15 +52,26 @@ type Props = {
 
 /** A failed admission keeps the draft and attachments available for retry. */
 export function Composer(
-	{ channel, chat: id, user, current, busy, ready, draft, onDraftLoaded, onSettings, accessory }:
-		Props,
+	{
+		channel,
+		chat: id,
+		user,
+		current,
+		currentEffort,
+		busy,
+		ready,
+		draft,
+		onDraftLoaded,
+		onSettings,
+		accessory,
+	}: Props,
 ) {
 	const composer = useRef<ChatComposerHandle>(null);
 	const sending = useRef(false);
 	const [pending, setPending] = useState(false);
 	const [attached, setAttached] = useState<Attachment[]>([]);
 	const [mode, setMode] = useState(chosen.get(channel.id) || "ace");
-	const [models, setModels] = useState<ModelRef[]>();
+	const [models, setModels] = useState<ModelOption[]>();
 	const [modelError, setModelError] = useState<string>();
 	const status = useSyncExternalStore(host.subscribe, () => host.status);
 	const settingsVersion = useSyncExternalStore(host.subscribe, () => host.settingsVersion);
@@ -62,7 +84,7 @@ export function Composer(
 		if (status !== "open" || mode !== "ace") return;
 		let active = true;
 		// Ask the channel itself: a hosted channel uses the service's credentials, not its workspace's.
-		host.channel<ModelRef[]>(channel.id, { op: "models" }).then(
+		host.channel<ModelOption[]>(channel.id, { op: "models" }).then(
 			(models) => {
 				if (!active) return;
 				setModels(models);
@@ -80,6 +102,19 @@ export function Composer(
 	}, [channel.id, mode, status, settingsVersion]);
 	const [picked, setPicked] = useState<string>();
 	const model = picked || (current ? key(current) : "auto");
+	const [pickedEffort, setPickedEffort] = useState<Effort>();
+	const levels = models?.find((value) => key(value) === model)?.efforts;
+	const requestedEffort = pickedEffort
+		|| (current && key(current) === model ? currentEffort : undefined) || "off";
+	const effort = requestedEffort === "off" || levels?.includes(requestedEffort)
+		? requestedEffort
+		: "off";
+	const efforts = levels && levels.some((level) => level !== "off")
+		? (levels.includes("off") ? levels : ["off" as const, ...levels]).map((id) => ({
+			id,
+			name: id === "off" && !levels.includes("off") ? "Default" : EFFORTS[id],
+		}))
+		: undefined;
 	const choices = (models || []).map((value) => ({
 		id: key(value),
 		name: value.modelId,
@@ -106,6 +141,7 @@ export function Composer(
 				const [provider, ...rest] = model.split("/");
 				await host.channel(channel.id, {
 					op: "ask",
+					...(levels ? { effort } : {}),
 					chat: id,
 					author: user,
 					text: body,
@@ -164,7 +200,13 @@ export function Composer(
 				mentions={MENTIONS}
 				models={choices}
 				model={model}
-				onModelChange={(value) => setPicked(value === "auto" ? undefined : value)}
+				onModelChange={(value) => {
+					setPicked(value === "auto" ? undefined : value);
+					setPickedEffort(undefined);
+				}}
+				efforts={efforts}
+				effort={effort}
+				onEffortChange={(value) => setPickedEffort(value as Effort)}
 				attachments={attached}
 				onAttachmentsChange={setAttached}
 				busy={busy}
 
@@ -101,6 +101,7 @@ export function Conversation(
 					chat={id}
 					user={user}
 					current={model}
+					currentEffort={chat?.effort}
 					busy={transcript.busy}
 					ready={transcript.live && channel.state !== "archived"}
 					draft={draft}
 
@@ -60,8 +60,12 @@ is one pi conversation in that Session.
   its runtime's default on its first invocation: the local host's current preference, or an available
   model on the hosting service. Availability is checked before admitting the input, so a rejected
   invocation queues no work and leaves its draft editable.
-- **Model per run.** The chat's model is set when a run is admitted. Changing it while a run is
-  active is rejected rather than changing the active run's later turns.
+- **Model and effort per run.** The chat's model and reasoning effort are set when a run is
+  admitted, stored in pi's agent configuration. Changing either while a run is active is rejected
+  rather than changing its later turns. Admissions are serialized per chat. The composer lists
+  levels from the channel's model catalog; Default leaves reasoning to always-thinking providers,
+  while Off disables it where supported. Switching models resets the composer's effort to that
+  model's default until a level is chosen.
 - **Subagents are child chats.** A subagent's chat is owned by the parent's tool task, so killing
   the parent kills the child. Agents in different channels only exchange messages.
 - **Lanes are Git worktrees** created by the chat's agent for each unit of work. A chat's working
 
@@ -1,4 +1,4 @@
-import type { Models } from "@earendil-works/pi-ai";
+import { getSupportedThinkingLevels, type Models } from "@earendil-works/pi-ai";
 import { BACKGROUND_CONTEXT as context } from "@earendil-works/chord/context";
 import {
 	AgentDoc,
@@ -36,6 +36,7 @@ import type {
 	ChannelInfo,
 	Chat,
 	ChatId,
+	Effort,
 	Event,
 	Metadata,
 	ModelRef,
@@ -88,6 +89,7 @@ export class Channel {
 	#log: Log;
 	#metadata: Metadata;
 	#active = 0;
+	#admissions = new Map<ChatId, Promise<unknown>>();
 	#listeners = new Set<{ chat: ChatId; send: Send }>();
 
 	private constructor(options: Options, harness: Harness, log: Log, value: Metadata) {
@@ -237,6 +239,7 @@ export class Channel {
 			if (window && used) chat.context = { used, window };
 			if (record.owner) chat.parent = record.owner.conversationId;
 			if (agent?.model) chat.model = agent.model;
+			chat.effort = agent?.thinkingLevel || "off";
 			if (lane) chat.lane = lane;
 			return chat;
 		}));
@@ -318,6 +321,19 @@ export class Channel {
 	}
 
 	async #ask(request: Extract<Request, { op: "ask" }>) {
+		const chat = request.chat || ROOT_CONVERSATION_ID;
+		const previous = this.#admissions.get(chat) || Promise.resolve();
+		// Selection and submission must stay together across concurrent clients.
+		const pending = previous.catch(() => {}).then(() => this.#admit(request));
+		this.#admissions.set(chat, pending);
+		try {
+			return await pending;
+		} finally {
+			if (this.#admissions.get(chat) === pending) this.#admissions.delete(chat);
+		}
+	}
+
+	async #admit(request: Extract<Request, { op: "ask" }>) {
 		this.#author(request.author);
 		room.checkImages(request.images);
 		const settings = await this.#harness.snapshot(SettingsDoc, context);
@@ -326,7 +342,7 @@ export class Channel {
 			throw new Error("Only the owner can invoke agents here");
 		}
 		const conversation = await this.#conversation(request.chat);
-		await this.#select(conversation, request.model);
+		await this.#select(conversation, request.model, request.effort);
 		const submission = await conversation.submit({
 			type: "input",
 			content: room.content(request.author, request.text, request.images),
@@ -336,19 +352,33 @@ export class Channel {
 		return { submission: submission.id };
 	}
 
-	/** A model applies to a whole run, so it cannot change while one is active. */
-	async #select(conversation: Conversation, requested: ModelRef | undefined) {
-		const current = (await conversation.agent(context)).model;
+	/** Model and effort apply to a whole run, never just its later turns. */
+	async #select(conversation: Conversation, requested: ModelRef | undefined, effort?: Effort) {
+		const agent = await conversation.agent(context);
+		const current = agent.model;
 		const model = requested || current || await (
 			this.#options.defaultModel?.() || choose(this.#options.models)
 		);
-		if (!this.#options.models.getModel(model.provider, model.modelId)) {
+		const selected = this.#options.models.getModel(model.provider, model.modelId);
+		if (!selected) {
 			throw new Error(`Unknown model ${model.provider}/${model.modelId}`);
 		}
-		const same = current?.provider === model.provider && current.modelId === model.modelId;
+		const levels = getSupportedThinkingLevels(selected);
+		if (effort !== undefined && effort !== "off" && !levels.includes(effort)) {
+			throw new Error(
+				`Unsupported reasoning effort ${effort} for ${model.provider}/${model.modelId}`,
+			);
+		}
+		// Pi's "off" means omit reasoning, allowing provider defaults on always-thinking models.
+		const thinkingLevel = effort
+			|| (levels.includes(agent.thinkingLevel) ? agent.thinkingLevel : "off");
+		const sameModel = current?.provider === model.provider && current.modelId === model.modelId;
+		const same = sameModel && thinkingLevel === agent.thinkingLevel;
 		const live = await this.#harness.snapshot(LiveDoc, conversation.id, context);
 		if (!same && live?.run) {
-			throw new Error("The chat is busy; stop it or wait before changing its model");
+			throw new Error(
+				"The chat is busy; stop it or wait before changing its model or reasoning effort",
+			);
 		}
 		const available = await this.#options.models.getAvailable(model.provider);
 		if (!available.some((value) => value.id === model.modelId)) {
@@ -357,7 +387,7 @@ export class Channel {
 			);
 		}
 		if (same) return;
-		await conversation.configure({ model }, context);
+		await conversation.configure({ model, thinkingLevel }, context);
 	}
 
 	async #chat(request: Extract<Request, { op: "chat" }>) {
 
@@ -1,18 +1,22 @@
-import type { Models } from "@earendil-works/pi-ai";
+import { getSupportedThinkingLevels, type Models } from "@earendil-works/pi-ai";
 
-import type { ModelRef } from "./protocol";
+import type { ModelOption, ModelRef } from "./protocol";
 
 const PREFERRED = ["anthropic/claude-opus-5-5", "openai/gpt-6-astra"];
 
 /** One inaccessible provider must not hide another provider's usable models. */
-export async function available(models: Models): Promise<ModelRef[]> {
+export async function available(models: Models): Promise<ModelOption[]> {
 	const results = await Promise.allSettled(
 		models.getProviders().map((provider) => models.getAvailable(provider.id)),
 	);
 	const found = results.flatMap((result) => result.status === "fulfilled" ? result.value : []);
 	const failed = results.find((result) => result.status === "rejected");
 	if (!found.length && failed?.status === "rejected") throw failed.reason;
-	return found.map(({ provider, id }) => ({ provider, modelId: id }));
+	return found.map((model) => ({
+		provider: model.provider,
+		modelId: model.id,
+		efforts: getSupportedThinkingLevels(model),
+	}));
 }
 
 /** Resolve an automatic choice only when admitting an agent invocation. */
@@ -26,5 +30,5 @@ export async function choose(models: Models): Promise<ModelRef> {
 			"Add a provider key for this channel before invoking an agent. Chat is still available.",
 		);
 	}
-	return selected;
+	return { provider: selected.provider, modelId: selected.modelId };
 }
@@ -1,6 +1,11 @@
+import type { ModelThinkingLevel } from "@earendil-works/pi-ai";
+
 /** The wire contract between a channel and its clients: one JSON value per line. */
 
 export type ModelRef = { provider: string; modelId: string };
+/** "off" leaves always-thinking providers at their default; otherwise disables reasoning. */
+export type Effort = ModelThinkingLevel;
+export type ModelOption = ModelRef & { efforts: Effort[] };
 
 /** Cumulative usage for one chat, including compaction and usage reported by tools. */
 export type Usage = {
@@ -35,6 +40,7 @@ export type Chat = {
 	parent?: ChatId;
 	busy: boolean;
 	model?: ModelRef;
+	effort?: Effort;
 	lane?: string;
 	/** Older hosts may not report usage. */
 	usage?: Usage;
@@ -146,6 +152,7 @@ export type Request =
 		text: string;
 		images?: Image[];
 		model?: ModelRef;
+		effort?: Effort;
 		requestId?: string;
 	}
 	| { op: "chat"; author: string; model?: ModelRef }
 
@@ -37,6 +37,7 @@ import {
 import {
 	DropdownMenu,
 	DropdownMenuContent,
+	DropdownMenuGroup,
 	DropdownMenuItem,
 	DropdownMenuLabel,
 	DropdownMenuSeparator,
@@ -1405,6 +1406,7 @@ function ComposerEffort({ state }: { state: ComposerState }) {
 			<DropdownMenuTrigger
 				render={
 					<Toolbar.Button
+						aria-label={`Reasoning effort: ${selected.name}`}
 						render={
 							<Button
 								variant="ghost"
@@ -1419,19 +1421,21 @@ function ComposerEffort({ state }: { state: ComposerState }) {
 				<IconChevronDownMicro className="size-3 transition-transform duration-150 group-data-[popup-open]/button:scale-y-[-1]" />
 			</DropdownMenuTrigger>
 			<DropdownMenuContent align="start" sideOffset={6} className="min-w-36">
-				<DropdownMenuLabel>Reasoning effort</DropdownMenuLabel>
-				{efforts?.map(entry => (
-					<DropdownMenuItem
-						key={entry.id}
-						onClick={() => {
-							onEffortChange(entry.id);
-							view.current?.focus();
-						}}
-					>
-						<span className="min-w-0 flex-1 truncate">{entry.name}</span>
-						{entry.id === effort && <IconCheckMicro className="size-3" />}
-					</DropdownMenuItem>
-				))}
+				<DropdownMenuGroup>
+					<DropdownMenuLabel>Reasoning effort</DropdownMenuLabel>
+					{efforts?.map(entry => (
+						<DropdownMenuItem
+							key={entry.id}
+							onClick={() => {
+								onEffortChange(entry.id);
+								view.current?.focus();
+							}}
+						>
+							<span className="min-w-0 flex-1 truncate">{entry.name}</span>
+							{entry.id === effort && <IconCheckMicro className="size-3" />}
+						</DropdownMenuItem>
+					))}
+				</DropdownMenuGroup>
 			</DropdownMenuContent>
 		</DropdownMenu>
 	);