diff --git a/app/src/features/bots/BotDialog.tsx b/app/src/features/bots/BotDialog.tsx
index 1b5153cc..b94e481a 100644
--- a/app/src/features/bots/BotDialog.tsx
+++ b/app/src/features/bots/BotDialog.tsx
@@ -3,6 +3,7 @@ import { type FormEvent, useState } from "react";
 import { useT } from "../../i18n";
 import { errorText } from "../../lib/api";
 import {
+  type AgentKind,
   AVATAR_PALETTE,
   type Bot,
   type BotModel,
@@ -17,6 +18,8 @@ import { BotAvatar } from "./BotAvatar";
 import { ColorPicker } from "./ColorPicker";
 
 const MODELS: BotModel[] = ["default", "fable", "opus", "sonnet", "haiku"];
+/** Stable, for a selector: a new array each time would render in a loop. */
+const CLAUDE_ONLY: AgentKind[] = ["claude"];
 
 type Props = { onClose(): void } & ({ crewId: CrewId; bot?: undefined } | { bot: Bot });
 
@@ -34,6 +37,12 @@ export function BotDialog(props: Props) {
   const custom = color !== undefined && !(AVATAR_PALETTE as readonly string[]).includes(color);
   const [picking, setPicking] = useState(custom);
   const [model, setModel] = useState<BotModel>(editing?.model ?? "default");
+  // One command prefix per line, for a bot whose agent cannot ask (spec 30).
+  const [commands, setCommands] = useState((editing?.allowedCommands ?? []).join("\n"));
+  // Which agent runs the bot is chosen once, when it is made (spec 30).
+  const agents = useApp((state) => state.system?.enabledAgents ?? CLAUDE_ONLY);
+  const [agent, setAgent] = useState<AgentKind>("claude");
+  const runsOn: AgentKind = editing?.agent ?? agent;
   const [error, setError] = useState<string | null>(null);
   const [busy, setBusy] = useState(false);
 
@@ -50,6 +59,10 @@ export function BotDialog(props: Props) {
           ...(role !== editing.role && { role }),
           ...(instructions !== editing.instructions && { instructions }),
           ...(color !== undefined && color !== editing.color && { color }),
+          ...(editing.agent !== "claude" &&
+            commands !== editing.allowedCommands.join("\n") && {
+              allowedCommands: commands.split("\n"),
+            }),
         });
         if (model !== editing.model) {
           // The bot restarts on it once nothing is in progress.
@@ -62,7 +75,8 @@ export function BotDialog(props: Props) {
           role,
           instructions,
           ...(color !== undefined && { color }),
-          ...(model !== "default" && { model }),
+          ...(runsOn === "claude" && model !== "default" && { model }),
+          ...(runsOn !== "claude" && { agent: runsOn }),
         });
       }
       putBot(bot);
@@ -118,13 +132,40 @@ export function BotDialog(props: Props) {
           placeholder={t.bots.dialog.instructionsPlaceholder}
           hint={editing ? t.bots.dialog.instructionsHint : undefined}
         />
-        <SelectField
-          label={t.chat.model.title}
-          value={model}
-          onChange={(event) => setModel(event.target.value as BotModel)}
-          options={MODELS.map((value) => ({ value, label: t.chat.model.names[value] }))}
-          hint={t.chat.model.cost}
-        />
+        {!editing && agents.length > 1 && (
+          <div className="flex flex-col gap-2">
+            <SelectField
+              label={t.bots.dialog.agent.title}
+              value={agent}
+              onChange={(event) => setAgent(event.target.value as AgentKind)}
+              options={agents.map((value) => ({ value, label: t.bots.dialog.agent.names[value] }))}
+            />
+            {agent !== "claude" && (
+              <p role="note" className="rounded-lg bg-sunken p-2.5 text-ink-soft text-xs">
+                {t.bots.dialog.agent.experimental}
+              </p>
+            )}
+          </div>
+        )}
+        {editing && editing.agent !== "claude" && (
+          <TextArea
+            label={t.bots.dialog.commands.title}
+            value={commands}
+            rows={4}
+            onChange={(event) => setCommands(event.target.value)}
+            placeholder={t.bots.dialog.commands.placeholder}
+            hint={t.bots.dialog.commands.hint}
+          />
+        )}
+        {runsOn === "claude" && (
+          <SelectField
+            label={t.chat.model.title}
+            value={model}
+            onChange={(event) => setModel(event.target.value as BotModel)}
+            options={MODELS.map((value) => ({ value, label: t.chat.model.names[value] }))}
+            hint={t.chat.model.cost}
+          />
+        )}
         <fieldset className="flex flex-col gap-1.5">
           <legend className="mb-1.5 font-medium text-ink-soft text-sm">
             {t.bots.dialog.color}
diff --git a/app/src/features/bots/agentPicker.test.tsx b/app/src/features/bots/agentPicker.test.tsx
new file mode 100644
index 00000000..d221ca3e
--- /dev/null
+++ b/app/src/features/bots/agentPicker.test.tsx
@@ -0,0 +1,32 @@
+import { cleanup, fireEvent, screen, within } from "@testing-library/react";
+import { afterEach, describe, expect, test } from "vitest";
+import { FakeBotloft } from "../../lib/fake";
+import { crewOpened, renderApp } from "../../test/app";
+
+afterEach(cleanup);
+
+async function openNewBot(agents: ("claude" | "agy")[]) {
+  const fake = new FakeBotloft();
+  fake.system = { ...fake.system, enabledAgents: agents };
+  fake.addCrew("Ops");
+  renderApp(fake);
+  await crewOpened("Ops");
+  const [button] = await screen.findAllByRole("button", { name: "New bot" });
+  fireEvent.click(button as HTMLElement);
+  return within(await screen.findByRole("dialog", { name: "New bot" }));
+}
+
+describe("choosing the agent of a new bot", () => {
+  test("with only Claude Code there is no choice to make", async () => {
+    const dialog = await openNewBot(["claude"]);
+    expect(dialog.queryByLabelText("Agent")).toBeNull();
+    expect(dialog.getByLabelText("Model")).toBeDefined();
+  });
+
+  test("an experimental agent comes with its warning and no model choice", async () => {
+    const dialog = await openNewBot(["claude", "agy"]);
+    fireEvent.change(dialog.getByLabelText("Agent"), { target: { value: "agy" } });
+    expect(dialog.getByRole("note").textContent).toMatch(/cannot ask you/);
+    expect(dialog.queryByLabelText("Model")).toBeNull();
+  });
+});
diff --git a/app/src/features/chat/AgentModelPicker.tsx b/app/src/features/chat/AgentModelPicker.tsx
new file mode 100644
index 00000000..3f591a56
--- /dev/null
+++ b/app/src/features/chat/AgentModelPicker.tsx
@@ -0,0 +1,109 @@
+// The model of a bot that does not run on Claude Code (spec 30), picked below
+// the chat like Claude's. The agent lists its models; its effort is part of
+// each name ("... (High)"), so there is no second picker.
+
+import { ChevronDown } from "lucide-react";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { useT } from "../../i18n";
+import type { AgentModel, Bot } from "../../lib/protocol.gen";
+import { useApi, useApp } from "../../store/context";
+import { POPOVER } from "../../ui/surface";
+import { attempt } from "../../ui/toast";
+import { useDismiss } from "../../ui/useDismiss";
+import { PickerOption } from "./PickerOption";
+
+export function AgentModelPicker({ bot, onLater }: { bot: Bot; onLater(text: string): void }) {
+  const api = useApi();
+  const putBot = useApp((state) => state.putBot);
+  const m = useT().chat.agentModel;
+  const [open, setOpen] = useState(false);
+  const [models, setModels] = useState<AgentModel[] | null>(null);
+  const [failed, setFailed] = useState(false);
+  const root = useRef<HTMLDivElement>(null);
+  const close = useCallback(() => setOpen(false), []);
+  useDismiss(open, root, close);
+
+  // Asked when the list is opened first: it takes a few seconds.
+  useEffect(() => {
+    if (!open || models !== null) {
+      return;
+    }
+    let live = true;
+    api
+      .call("agents.models", { agent: bot.agent })
+      .then((list) => live && setModels(list))
+      .catch(() => live && setFailed(true));
+    return () => {
+      live = false;
+    };
+  }, [open, models, api, bot.agent]);
+
+  const current = bot.agentModel;
+  const nameOf = (id: string) => models?.find((model) => model.id === id)?.name ?? id;
+  const label =
+    current === null ? (bot.modelInUse ? nameOf(bot.modelInUse) : m.short) : nameOf(current);
+
+  const choose = async (model: string | null) => {
+    setOpen(false);
+    if (model === current) {
+      return;
+    }
+    const working = bot.state === "busy" || bot.state === "needs_approval";
+    await attempt(m.failed, async () => {
+      putBot(await api.call("bots.setAgentModel", { botId: bot.id, model }));
+      if (working) {
+        onLater(m.later(bot.name, model === null ? m.short : nameOf(model)));
+      }
+    });
+  };
+
+  return (
+    <div ref={root} className="relative min-w-0">
+      {open && (
+        <div
+          role="menu"
+          aria-label={m.title}
+          className={`absolute right-0 bottom-full mb-2 max-h-80 w-[22rem] max-w-[80vw] origin-bottom-right overflow-y-auto ${POPOVER}`}
+        >
+          <p className="px-2.5 pt-1.5 pb-1 font-medium text-muted text-xs">{m.title}</p>
+          <PickerOption
+            name={m.short}
+            hint={m.defaultHint(bot.name)}
+            checked={current === null}
+            onSelect={() => choose(null)}
+          />
+          {models === null && !failed && (
+            <p className="px-2.5 py-2 text-muted text-xs">{m.loading}</p>
+          )}
+          {failed && <p className="px-2.5 py-2 text-danger text-xs">{m.listFailed}</p>}
+          {models?.map((model) => (
+            <PickerOption
+              key={model.id}
+              name={model.name}
+              hint={model.id}
+              checked={current === model.id}
+              onSelect={() => choose(model.id)}
+            />
+          ))}
+        </div>
+      )}
+      <button
+        type="button"
+        aria-haspopup="menu"
+        aria-expanded={open}
+        aria-label={m.button(label)}
+        onClick={() => setOpen(!open)}
+        className={`flex h-8 max-w-full items-center gap-1 rounded-full px-2.5 text-sm text-ink-soft transition-colors hover:bg-sunken hover:text-ink ${
+          open ? "bg-sunken text-ink" : ""
+        }`}
+      >
+        <span className="truncate">{label}</span>
+        <ChevronDown
+          aria-hidden
+          size={14}
+          className={`hidden shrink-0 opacity-60 transition-transform duration-200 @xs:block ${open ? "rotate-180" : ""}`}
+        />
+      </button>
+    </div>
+  );
+}
diff --git a/app/src/features/chat/ChatComposer.tsx b/app/src/features/chat/ChatComposer.tsx
index ddd2afcb..c0ca0818 100644
--- a/app/src/features/chat/ChatComposer.tsx
+++ b/app/src/features/chat/ChatComposer.tsx
@@ -22,6 +22,7 @@ import { type Bot, FIELD_LIMITS } from "../../lib/protocol.gen";
 import { prefs, usePref } from "../../shell/prefs";
 import { playSound } from "../../shell/sounds";
 import { useApi } from "../../store/context";
+import { AgentModelPicker } from "./AgentModelPicker";
 import { ContextMeter } from "./ContextMeter";
 import { draftOf, keepDraft } from "./drafts";
 import { EffortPicker } from "./EffortPicker";
@@ -246,8 +247,15 @@ export const ChatComposer = memo(function ChatComposer({
           </span>
           <div className="ml-auto flex min-w-0 max-w-full items-center gap-1">
             <ContextMeter bot={bot} onLater={setLater} />
-            <EffortPicker bot={bot} onLater={setLater} />
-            <ModelPicker bot={bot} onLater={setLater} />
+            {/* Another agent's effort is part of its model's name (spec 30). */}
+            {bot.agent === "claude" ? (
+              <>
+                <EffortPicker bot={bot} onLater={setLater} />
+                <ModelPicker bot={bot} onLater={setLater} />
+              </>
+            ) : (
+              <AgentModelPicker bot={bot} onLater={setLater} />
+            )}
             <button
               type="submit"
               aria-label={t.chat.composer.send}
diff --git a/app/src/features/chat/ContextMeter.tsx b/app/src/features/chat/ContextMeter.tsx
index 5ff66eb7..7ba43671 100644
--- a/app/src/features/chat/ContextMeter.tsx
+++ b/app/src/features/chat/ContextMeter.tsx
@@ -38,6 +38,7 @@ export function ContextMeter({ bot, onLater }: { bot: Bot; onLater(text: string)
   const limit = autoCompactTokens ?? windowTokens;
   const near = usedTokens >= limit * NEAR;
   const left = autoCompactTokens === null ? null : autoCompactTokens - usedTokens;
+  const claude = bot.agent === "claude";
   const running = bot.state === "idle" || bot.state === "busy" || bot.state === "needs_approval";
 
   const compact = async () => {
@@ -76,26 +77,31 @@ export function ContextMeter({ bot, onLater }: { bot: Bot; onLater(text: string)
             )}
           </div>
           <p className="mt-2 text-ink-soft text-sm">
-            {left === null
-              ? m.noAuto
-              : left > 0
-                ? m.autoLeft(tokens(left), tokens(autoCompactTokens ?? 0))
-                : m.autoNow}
+            {!claude
+              ? m.estimate
+              : left === null
+                ? m.noAuto
+                : left > 0
+                  ? m.autoLeft(tokens(left), tokens(autoCompactTokens ?? 0))
+                  : m.autoNow}
           </p>
           <p className="mt-1.5 text-muted text-xs">{m.about(bot.name)}</p>
-          <div className="mt-3 border-line border-t pt-3">
-            <Button
-              size="sm"
-              disabled={compacting || !running}
-              aria-busy={compacting}
-              onClick={compact}
-            >
-              {compacting ? m.compacting : m.compact}
-            </Button>
-            <p className="mt-1.5 text-muted text-xs">
-              {running || compacting ? m.compactHint(bot.name) : m.notRunning(bot.name)}
-            </p>
-          </div>
+          {/* Only Claude Code answers a request to compact (spec 30). */}
+          {claude && (
+            <div className="mt-3 border-line border-t pt-3">
+              <Button
+                size="sm"
+                disabled={compacting || !running}
+                aria-busy={compacting}
+                onClick={compact}
+              >
+                {compacting ? m.compacting : m.compact}
+              </Button>
+              <p className="mt-1.5 text-muted text-xs">
+                {running || compacting ? m.compactHint(bot.name) : m.notRunning(bot.name)}
+              </p>
+            </div>
+          )}
         </div>
       )}
       <button
diff --git a/app/src/features/chat/agentBot.test.tsx b/app/src/features/chat/agentBot.test.tsx
new file mode 100644
index 00000000..a2e76a5e
--- /dev/null
+++ b/app/src/features/chat/agentBot.test.tsx
@@ -0,0 +1,90 @@
+import { cleanup, fireEvent, screen, waitFor, within } from "@testing-library/react";
+import { afterEach, describe, expect, test } from "vitest";
+import { FakeBotloft } from "../../lib/fake";
+import { crewOpened, openBot, renderApp, sidebar } from "../../test/app";
+
+afterEach(cleanup);
+
+async function agyBot() {
+  const fake = new FakeBotloft();
+  const crew = fake.addCrew("Ops");
+  const bot = fake.addBot(crew.id, "Zed");
+  fake.bot(bot.id).agent = "agy";
+  fake.setBotState(bot.id, "idle");
+  fake.setContext(bot.id, {
+    usedTokens: 120_000,
+    windowTokens: 1_000_000,
+    autoCompactTokens: null,
+    compacting: false,
+    updatedAt: 0,
+  });
+  renderApp(fake);
+  await crewOpened("Ops");
+  openBot("Zed");
+  await screen.findByRole("list", { name: "Messages" });
+  return fake;
+}
+
+describe("a bot that runs on another agent", () => {
+  test("shows its models, not Claude's, and picks one", async () => {
+    const fake = await agyBot();
+    expect(screen.queryByRole("button", { name: /^Effort:/ })).toBeNull();
+    expect(screen.queryByRole("button", { name: /Plan default|Opus|Sonnet/ })).toBeNull();
+
+    fireEvent.click(screen.getByRole("button", { name: "Model: Default" }));
+    const menu = await screen.findByRole("menu", { name: "Model" });
+    fireEvent.click(
+      await within(menu).findByRole("menuitemradio", { name: /Gemini 3.8 Flash \(High\)/ }),
+    );
+    await waitFor(() =>
+      expect(fake.bots.values().next().value?.agentModel).toBe("gemini-3.8-flash-high"),
+    );
+  });
+
+  test("shows how full the conversation is, without a way to compact it", async () => {
+    await agyBot();
+    fireEvent.click(screen.getByRole("button", { name: /Conversation space/ }));
+    const panel = await screen.findByRole("dialog", { name: "Conversation space" });
+    expect(within(panel).getByText(/An estimate/)).toBeDefined();
+    expect(within(panel).queryByRole("button", { name: "Compact now" })).toBeNull();
+  });
+});
+
+describe("what an agent that cannot ask needs from the owner", () => {
+  test("the commands it may run are a list in the bot's edit dialog", async () => {
+    const fake = await agyBot();
+    const bot = [...fake.bots.values()][0];
+    expect(bot?.allowedCommands).toEqual([]);
+    // The bot's right-click menu in the list opens its edit dialog.
+    fireEvent.contextMenu(within(sidebar()).getByRole("button", { name: /^Zed,/ }), {
+      clientX: 120,
+      clientY: 200,
+    });
+    const menu = await screen.findByRole("menu", { name: "Actions for Zed" });
+    fireEvent.click(within(menu).getByRole("menuitem", { name: "Edit" }));
+    const dialog = within(await screen.findByRole("dialog", { name: /Edit Zed/ }));
+    fireEvent.change(dialog.getByLabelText("Commands this bot may run"), {
+      target: { value: "git status\n npm test \ngit status" },
+    });
+    fireEvent.click(dialog.getByRole("button", { name: "Save" }));
+    await waitFor(() => expect(bot?.allowedCommands).toEqual(["git status", "npm test"]));
+  });
+});
+
+describe("Claude Code missing", () => {
+  test("is only a warning for someone who has a bot that runs on it", async () => {
+    const make = async (agent: "claude" | "agy") => {
+      const fake = new FakeBotloft();
+      fake.system = { ...fake.system, runtimeError: "Claude Code was not found" };
+      const crew = fake.addCrew("Ops");
+      fake.bot(fake.addBot(crew.id, "Zed").id).agent = agent;
+      renderApp(fake);
+      await crewOpened("Ops");
+    };
+    await make("agy");
+    expect(screen.queryByText("Bots can't start")).toBeNull();
+    cleanup();
+    await make("claude");
+    expect(await screen.findByText("Bots can't start")).toBeDefined();
+  });
+});
diff --git a/app/src/i18n/en/bots.ts b/app/src/i18n/en/bots.ts
index 4a838e89..b8337963 100644
--- a/app/src/i18n/en/bots.ts
+++ b/app/src/i18n/en/bots.ts
@@ -97,6 +97,21 @@ export const bots = {
     instructions: "Instructions",
     instructionsPlaceholder: "How this bot works, what it may do on its own and when to ask.",
     instructionsHint: "Saved to the bot's rules now; the bot reads them the next time it starts.",
+    commands: {
+      title: "Commands this bot may run",
+      placeholder: "git status\nnpm test",
+      hint: "One command per line; it may run these and anything that starts with them, without asking you. It cannot ask, so everything else is refused. A single * lets it run anything. The bot restarts to use the list.",
+    },
+    agent: {
+      title: "Agent",
+      names: {
+        claude: "Claude Code",
+        agy: "Antigravity (experimental)",
+        codex: "Codex",
+      },
+      experimental:
+        "Experimental. This bot cannot ask you before it acts. It can work with files in its own folders and use the crew's tools, but it cannot run commands, and it has no usage meter or model choice.",
+    },
     color: "Color",
     swatch: (color: string) => `Color ${color}`,
     colorUnset: "Left unset, the bot gets the crew's next color.",
diff --git a/app/src/i18n/en/chat.ts b/app/src/i18n/en/chat.ts
index 546791bf..f38ad4f8 100644
--- a/app/src/i18n/en/chat.ts
+++ b/app/src/i18n/en/chat.ts
@@ -198,6 +198,16 @@ export const chat = {
     later: (bot: string, model: string) =>
       `${bot} switches to ${model} when it finishes what it's doing.`,
   },
+  agentModel: {
+    title: "Model",
+    button: (model: string) => `Model: ${model}`,
+    short: "Default",
+    loading: "Loading the models…",
+    listFailed: "Could not load the list of models",
+    failed: "Could not change the model",
+    defaultHint: (bot: string) => `${bot} uses the agent's own default model`,
+    later: (bot: string, model: string) => `${bot} switches to ${model}.`,
+  },
   effort: {
     title: "Effort",
     button: (level: string) => `Effort: ${level}`,
@@ -242,6 +252,8 @@ export const chat = {
     autoLeft: (left: string, at: string) => `${left} left before it compacts by itself, at ${at}.`,
     autoNow: "It is full enough to compact by itself on the next message.",
     noAuto: "It does not compact by itself.",
+    estimate:
+      "An estimate: this agent does not say how large its window is, so the size comes from its model family.",
     compact: "Compact now",
     compactHint: (bot: string) =>
       `Replaces what came before with a summary, so ${bot} has room again and each message uses less.`,
diff --git a/app/src/i18n/es/bots.ts b/app/src/i18n/es/bots.ts
index 39c757d9..ca923559 100644
--- a/app/src/i18n/es/bots.ts
+++ b/app/src/i18n/es/bots.ts
@@ -95,6 +95,21 @@ export const bots: Messages["bots"] = {
       "Cómo trabaja este bot, qué puede hacer por su cuenta y cuándo debe preguntar.",
     instructionsHint:
       "Se guardan ahora en las reglas del bot; el bot las lee la próxima vez que se inicie.",
+    commands: {
+      title: "Comandos que este bot puede ejecutar",
+      placeholder: "git status\nnpm test",
+      hint: "Un comando por línea; puede ejecutar estos y lo que empiece con ellos, sin preguntarte. No puede preguntar, así que todo lo demás se rechaza. Un * solo permite ejecutar cualquier cosa. El bot se reinicia para usar la lista.",
+    },
+    agent: {
+      title: "Agente",
+      names: {
+        claude: "Claude Code",
+        agy: "Antigravity (experimental)",
+        codex: "Codex",
+      },
+      experimental:
+        "Experimental. Este bot no puede preguntarte antes de actuar. Trabaja con archivos de sus propias carpetas y usa las herramientas del equipo, pero no ejecuta comandos, y no tiene medidor de uso ni elección de modelo.",
+    },
     color: "Color",
     swatch: (color: string) => `Color ${color}`,
     colorUnset: "Si no eliges uno, el bot recibe el siguiente color del equipo.",
diff --git a/app/src/i18n/es/chat.ts b/app/src/i18n/es/chat.ts
index 5f2f6720..17f1d984 100644
--- a/app/src/i18n/es/chat.ts
+++ b/app/src/i18n/es/chat.ts
@@ -190,6 +190,16 @@ export const chat: Messages["chat"] = {
     later: (bot: string, model: string) =>
       `${bot} cambia a ${model} cuando termine lo que está haciendo.`,
   },
+  agentModel: {
+    title: "Modelo",
+    button: (model: string) => `Modelo: ${model}`,
+    short: "Predeterminado",
+    loading: "Cargando los modelos…",
+    listFailed: "No se pudo cargar la lista de modelos",
+    failed: "No se pudo cambiar el modelo",
+    defaultHint: (bot: string) => `${bot} usa el modelo predeterminado del propio agente`,
+    later: (bot: string, model: string) => `${bot} cambia a ${model}.`,
+  },
   effort: {
     title: "Esfuerzo",
     button: (level: string) => `Esfuerzo: ${level}`,
@@ -234,6 +244,8 @@ export const chat: Messages["chat"] = {
     autoLeft: (left: string, at: string) => `Faltan ${left} para que se compacte sola, en ${at}.`,
     autoNow: "Ya está lo bastante llena para compactarse sola en el próximo mensaje.",
     noAuto: "No se compacta sola.",
+    estimate:
+      "Una estimación: este agente no dice el tamaño de su ventana, así que el tamaño sale de la familia del modelo.",
     compact: "Compactar ahora",
     compactHint: (bot: string) =>
       `Cambia lo anterior por un resumen: ${bot} vuelve a tener espacio y cada mensaje gasta menos.`,
diff --git a/app/src/i18n/pt-BR/bots.ts b/app/src/i18n/pt-BR/bots.ts
index 6e8c10e5..20832680 100644
--- a/app/src/i18n/pt-BR/bots.ts
+++ b/app/src/i18n/pt-BR/bots.ts
@@ -94,6 +94,21 @@ export const bots: Messages["bots"] = {
     instructionsPlaceholder:
       "Como este bot trabalha, o que ele pode fazer sozinho e quando deve perguntar.",
     instructionsHint: "Salvas agora nas regras do bot; ele as lê na próxima vez que iniciar.",
+    commands: {
+      title: "Comandos que este bot pode rodar",
+      placeholder: "git status\nnpm test",
+      hint: "Um comando por linha; ele pode rodar estes e o que começar com eles, sem perguntar a você. Ele não consegue perguntar, então todo o resto é recusado. Um * sozinho deixa rodar qualquer coisa. O bot reinicia para usar a lista.",
+    },
+    agent: {
+      title: "Agente",
+      names: {
+        claude: "Claude Code",
+        agy: "Antigravity (experimental)",
+        codex: "Codex",
+      },
+      experimental:
+        "Experimental. Este bot não consegue perguntar a você antes de agir. Ele trabalha com arquivos das próprias pastas e usa as ferramentas da equipe, mas não roda comandos, e não tem medidor de uso nem escolha de modelo.",
+    },
     color: "Cor",
     swatch: (color: string) => `Cor ${color}`,
     colorUnset: "Se você não escolher, o bot recebe a próxima cor da equipe.",
diff --git a/app/src/i18n/pt-BR/chat.ts b/app/src/i18n/pt-BR/chat.ts
index 8854f686..d2711870 100644
--- a/app/src/i18n/pt-BR/chat.ts
+++ b/app/src/i18n/pt-BR/chat.ts
@@ -186,6 +186,16 @@ export const chat: Messages["chat"] = {
     later: (bot: string, model: string) =>
       `${bot} muda para ${model} quando terminar o que está fazendo.`,
   },
+  agentModel: {
+    title: "Modelo",
+    button: (model: string) => `Modelo: ${model}`,
+    short: "Padrão",
+    loading: "Carregando os modelos…",
+    listFailed: "Não foi possível carregar a lista de modelos",
+    failed: "Não foi possível trocar o modelo",
+    defaultHint: (bot: string) => `${bot} usa o modelo padrão do próprio agente`,
+    later: (bot: string, model: string) => `${bot} troca para ${model}.`,
+  },
   effort: {
     title: "Esforço",
     button: (level: string) => `Esforço: ${level}`,
@@ -231,6 +241,8 @@ export const chat: Messages["chat"] = {
       `Faltam ${left} para ela se compactar sozinha, em ${at}.`,
     autoNow: "Já está cheia o bastante para se compactar sozinha na próxima mensagem.",
     noAuto: "Ela não se compacta sozinha.",
+    estimate:
+      "Uma estimativa: este agente não informa o tamanho da janela, então o tamanho vem da família do modelo.",
     compact: "Compactar agora",
     compactHint: (bot: string) =>
       `Troca o que veio antes por um resumo: ${bot} volta a ter espaço e cada mensagem gasta menos.`,
diff --git a/app/src/lib/fake.ts b/app/src/lib/fake.ts
index 8d200dba..10536876 100644
--- a/app/src/lib/fake.ts
+++ b/app/src/lib/fake.ts
@@ -69,6 +69,7 @@ export class FakeBotloft implements BotloftApi {
     },
     deliveries: { pending: 0, dead: 0 },
     usage: null,
+    enabledAgents: ["claude"],
   };
   /** How many times the app asked for a new Claude Code check. */
   refreshes = 0;
@@ -252,6 +253,10 @@ export class FakeBotloft implements BotloftApi {
       daemonVersion: this.system.daemonVersion,
       protocol: PROTOCOL_VERSION,
     }),
+    "agents.models": () => [
+      { id: "gemini-3.8-flash-low", name: "Gemini 3.8 Flash (Low)" },
+      { id: "gemini-3.8-flash-high", name: "Gemini 3.8 Flash (High)" },
+    ],
     "session.setLocale": ({ locale }) => {
       this.locale = locale;
       return null;
diff --git a/app/src/lib/fakeBots.ts b/app/src/lib/fakeBots.ts
index 706f1807..ce9647fc 100644
--- a/app/src/lib/fakeBots.ts
+++ b/app/src/lib/fakeBots.ts
@@ -17,7 +17,7 @@ export function botHandlers(fake: FakeBotloft): Pick<Handlers, BotMethods> {
       }
       return fake.activeBots(crewId);
     },
-    "bots.create": ({ crewId, name, role, instructions, color, model }) => {
+    "bots.create": ({ crewId, name, role, instructions, color, model, agent }) => {
       const crew = fake.crew(crewId);
       const checked = checkName(name);
       const handle = fake.handle(checked, crewId);
@@ -33,7 +33,9 @@ export function botHandlers(fake: FakeBotloft): Pick<Handlers, BotMethods> {
         color: color ?? AVATAR_PALETTE[index % AVATAR_PALETTE.length] ?? "#FF7A59",
         paused: false,
         permissionMode: "default",
-        agent: "claude",
+        agent: agent ?? "claude",
+        agentModel: null,
+        allowedCommands: [],
         model: model ?? "default",
         modelInUse: null,
         effort: "default",
@@ -50,7 +52,7 @@ export function botHandlers(fake: FakeBotloft): Pick<Handlers, BotMethods> {
       fake.bots.set(bot.id, bot);
       return fake.changedBot(bot);
     },
-    "bots.update": ({ botId, name, role, instructions, color }) => {
+    "bots.update": ({ botId, name, role, instructions, color, allowedCommands }) => {
       const bot = fake.bot(botId);
       if (name !== undefined) {
         bot.name = checkName(name);
@@ -59,6 +61,11 @@ export function botHandlers(fake: FakeBotloft): Pick<Handlers, BotMethods> {
       bot.role = role?.trim() ?? bot.role;
       bot.instructions = instructions ?? bot.instructions;
       bot.color = color ?? bot.color;
+      if (allowedCommands !== undefined) {
+        bot.allowedCommands = [
+          ...new Set(allowedCommands.map((line) => line.trim()).filter(Boolean)),
+        ];
+      }
       return fake.changedBot(bot);
     },
     "bots.setPaused": ({ botId, paused }) => {
@@ -80,6 +87,11 @@ export function botHandlers(fake: FakeBotloft): Pick<Handlers, BotMethods> {
       }
       return fake.changedBot(bot);
     },
+    "bots.setAgentModel": ({ botId, model }) => {
+      const bot = fake.bot(botId);
+      bot.agentModel = model;
+      return fake.changedBot(bot);
+    },
     "bots.setEffort": ({ botId, effort }) => {
       const bot = fake.bot(botId);
       bot.effort = effort;
diff --git a/app/src/lib/protocol.gen.ts b/app/src/lib/protocol.gen.ts
index 09ecdc5f..b5560a6e 100644
--- a/app/src/lib/protocol.gen.ts
+++ b/app/src/lib/protocol.gen.ts
@@ -242,7 +242,17 @@ color: string, paused: boolean, permissionMode: PermissionMode,
 /**
  * The agent behind the bot.
  */
-agent: AgentKind, model: BotModel, 
+agent: AgentKind, 
+/**
+ * The model of a bot that does not run on Claude Code, as its agent
+ * names it; `null` for the agent's default (spec 30).
+ */
+agentModel: string | null, 
+/**
+ * Command prefixes a bot not on Claude Code may run without asking:
+ * its agent cannot ask in headless mode (spec 30). `*` is every command.
+ */
+allowedCommands: Array<string>, model: BotModel, 
 /**
  * The model id Claude Code reported when the bot last started a turn
  * (`claude-opus-5-5`); `null` before its first turn.
@@ -398,7 +408,12 @@ account: OwnerAccount, deliveries: DeliveryBacklog,
 /**
  * The Claude account's usage as last reported; `null` before any turn.
  */
-usage: AccountUsage | null, };
+usage: AccountUsage | null, 
+/**
+ * The agents a bot may be made for (spec 30): Claude Code, and the
+ * experimental ones the owner switched on.
+ */
+enabledAgents: Array<AgentKind>, };
 
 export type CrewsCreateParams = { name: string, 
 /**
@@ -464,7 +479,11 @@ agent?: AgentKind, };
 /**
  * Fields left out stay unchanged.
  */
-export type BotsUpdateParams = { botId: BotId, name?: string, role?: string, instructions?: string, color?: string, };
+export type BotsUpdateParams = { botId: BotId, name?: string, role?: string, instructions?: string, color?: string, 
+/**
+ * For a bot not on Claude Code; replaces the whole list.
+ */
+allowedCommands?: Array<string>, };
 
 export type BotsSetPausedParams = { botId: BotId, paused: boolean, };
 
@@ -472,6 +491,29 @@ export type BotsSetPermissionModeParams = { botId: BotId, mode: PermissionMode,
 
 export type BotsSetModelParams = { botId: BotId, model: BotModel, };
 
+/**
+ * Params of `bots.setAgentModel` (spec 30).
+ */
+export type BotsSetAgentModelParams = { botId: BotId, 
+/**
+ * An id from `agents.models`; `null` goes back to the agent's default.
+ */
+model: string | null, };
+
+/**
+ * Params of `agents.models`.
+ */
+export type AgentsModelsParams = { agent: AgentKind, };
+
+/**
+ * A model an agent offers.
+ */
+export type AgentModel = { id: string, 
+/**
+ * As the agent names it for people.
+ */
+name: string, };
+
 export type BotIdParams = { botId: BotId, };
 
 export type BotsRestartParams = { botId: BotId, 
@@ -2180,6 +2222,8 @@ export interface RpcMethods {
   "bots.setPaused": { params: BotsSetPausedParams; result: Bot };
   "bots.setPermissionMode": { params: BotsSetPermissionModeParams; result: Bot };
   "bots.setModel": { params: BotsSetModelParams; result: Bot };
+  "bots.setAgentModel": { params: BotsSetAgentModelParams; result: Bot };
+  "agents.models": { params: AgentsModelsParams; result: AgentModel[] };
   "bots.archive": { params: BotIdParams; result: Bot };
   "bots.delete": { params: BotsDeleteParams; result: BotDeleted };
   "bots.restart": { params: BotsRestartParams; result: Bot };
diff --git a/app/src/shell/Workspace.tsx b/app/src/shell/Workspace.tsx
index c24838e2..23a34ef1 100644
--- a/app/src/shell/Workspace.tsx
+++ b/app/src/shell/Workspace.tsx
@@ -40,8 +40,15 @@ export function Workspace() {
   const loadError = useApp((state) => state.loadError);
   const hasCrews = useApp((state) => Object.keys(state.crews).length > 0);
   const page = useApp((state) => state.page);
-  const runtimeError = useApp((state) => state.system?.runtimeError ?? null);
-  const signedOut = useApp((state) => state.system?.claudeSignedIn === false);
+  // Claude Code missing or signed out only matters to bots that run on it.
+  const needsClaude = useApp((state) => {
+    const bots = Object.values(state.bots);
+    return bots.length === 0 || bots.some((bot) => bot.agent === "claude");
+  });
+  const runtimeError = useApp((state) =>
+    needsClaude ? (state.system?.runtimeError ?? null) : null,
+  );
+  const signedOut = useApp((state) => needsClaude && state.system?.claudeSignedIn === false);
   useAttentionMark();
   useTray();
   useBotAlerts();
diff --git a/crates/botloft-core/src/protocol/export.rs b/crates/botloft-core/src/protocol/export.rs
index f294d368..9684940c 100644
--- a/crates/botloft-core/src/protocol/export.rs
+++ b/crates/botloft-core/src/protocol/export.rs
@@ -157,6 +157,9 @@ fn export_bindings() {
     out.decl::<BotsSetPausedParams>();
     out.decl::<BotsSetPermissionModeParams>();
     out.decl::<BotsSetModelParams>();
+    out.decl::<BotsSetAgentModelParams>();
+    out.decl::<AgentsModelsParams>();
+    out.decl::<AgentModel>();
     out.decl::<BotIdParams>();
     out.decl::<BotsRestartParams>();
     out.decl::<BotStateChanged>();
@@ -313,6 +316,16 @@ fn export_bindings() {
         &out.name::<BotsSetModelParams>(),
         &bot,
     );
+    out.method(
+        method::BOTS_SET_AGENT_MODEL,
+        &out.name::<BotsSetAgentModelParams>(),
+        &bot,
+    );
+    out.method(
+        method::AGENTS_MODELS,
+        &out.name::<AgentsModelsParams>(),
+        &format!("{}[]", out.name::<AgentModel>()),
+    );
     out.method(method::BOTS_ARCHIVE, &out.name::<BotIdParams>(), &bot);
     out.method(
         method::BOTS_DELETE,
diff --git a/crates/botloft-core/src/protocol/methods.rs b/crates/botloft-core/src/protocol/methods.rs
index 68028e05..c4390409 100644
--- a/crates/botloft-core/src/protocol/methods.rs
+++ b/crates/botloft-core/src/protocol/methods.rs
@@ -78,6 +78,9 @@ pub struct SystemStatus {
     pub deliveries: DeliveryBacklog,
     /// The Claude account's usage as last reported; `null` before any turn.
     pub usage: Option<AccountUsage>,
+    /// The agents a bot may be made for (spec 30): Claude Code, and the
+    /// experimental ones the owner switched on.
+    pub enabled_agents: Vec<AgentKind>,
 }
 
 /// The owner, as the app shows them in its account area (spec 15.1).
@@ -259,6 +262,10 @@ pub struct BotsUpdateParams {
     #[serde(default)]
     #[cfg_attr(test, ts(optional))]
     pub color: Option<String>,
+    /// For a bot not on Claude Code; replaces the whole list.
+    #[serde(default)]
+    #[cfg_attr(test, ts(optional))]
+    pub allowed_commands: Option<Vec<String>>,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
@@ -285,6 +292,34 @@ pub struct BotsSetModelParams {
     pub model: BotModel,
 }
 
+/// Params of `bots.setAgentModel` (spec 30).
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+#[cfg_attr(test, derive(ts_rs::TS))]
+pub struct BotsSetAgentModelParams {
+    pub bot_id: BotId,
+    /// An id from `agents.models`; `null` goes back to the agent's default.
+    pub model: Option<String>,
+}
+
+/// Params of `agents.models`.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+#[cfg_attr(test, derive(ts_rs::TS))]
+pub struct AgentsModelsParams {
+    pub agent: AgentKind,
+}
+
+/// A model an agent offers.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+#[cfg_attr(test, derive(ts_rs::TS))]
+pub struct AgentModel {
+    pub id: String,
+    /// As the agent names it for people.
+    pub name: String,
+}
+
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 #[cfg_attr(test, derive(ts_rs::TS))]
diff --git a/crates/botloft-core/src/protocol/mod.rs b/crates/botloft-core/src/protocol/mod.rs
index d0daf516..40ded9b2 100644
--- a/crates/botloft-core/src/protocol/mod.rs
+++ b/crates/botloft-core/src/protocol/mod.rs
@@ -130,6 +130,8 @@ pub mod method {
     pub const BOTS_SET_PAUSED: &str = "bots.setPaused";
     pub const BOTS_SET_PERMISSION_MODE: &str = "bots.setPermissionMode";
     pub const BOTS_SET_MODEL: &str = "bots.setModel";
+    pub const BOTS_SET_AGENT_MODEL: &str = "bots.setAgentModel";
+    pub const AGENTS_MODELS: &str = "agents.models";
     pub const BOTS_SET_EFFORT: &str = "bots.setEffort";
     pub const BOTS_COMPACT: &str = "bots.compact";
     pub const BOTS_ARCHIVE: &str = "bots.archive";
diff --git a/crates/botloft-core/src/protocol/model.rs b/crates/botloft-core/src/protocol/model.rs
index d43e47b4..732b2b4f 100644
--- a/crates/botloft-core/src/protocol/model.rs
+++ b/crates/botloft-core/src/protocol/model.rs
@@ -149,6 +149,12 @@ pub struct Bot {
     pub permission_mode: PermissionMode,
     /// The agent behind the bot.
     pub agent: AgentKind,
+    /// The model of a bot that does not run on Claude Code, as its agent
+    /// names it; `null` for the agent's default (spec 30).
+    pub agent_model: Option<String>,
+    /// Command prefixes a bot not on Claude Code may run without asking:
+    /// its agent cannot ask in headless mode (spec 30). `*` is every command.
+    pub allowed_commands: Vec<String>,
     pub model: BotModel,
     /// The model id Claude Code reported when the bot last started a turn
     /// (`claude-opus-5-5`); `null` before its first turn.
diff --git a/crates/botloft-store/migrations/0027_bot_agent_model.sql b/crates/botloft-store/migrations/0027_bot_agent_model.sql
new file mode 100644
index 00000000..3358b6af
--- /dev/null
+++ b/crates/botloft-store/migrations/0027_bot_agent_model.sql
@@ -0,0 +1,3 @@
+-- The model of a bot whose agent is not Claude Code (spec 30): an id the
+-- agent lists, NULL for the agent's own default.
+ALTER TABLE bots ADD COLUMN agent_model TEXT;
diff --git a/crates/botloft-store/migrations/0028_bot_allowed_commands.sql b/crates/botloft-store/migrations/0028_bot_allowed_commands.sql
new file mode 100644
index 00000000..ca63fb2e
--- /dev/null
+++ b/crates/botloft-store/migrations/0028_bot_allowed_commands.sql
@@ -0,0 +1,3 @@
+-- Shell commands the owner lets a bot run when its agent cannot ask (spec 30):
+-- a JSON array of command prefixes.
+ALTER TABLE bots ADD COLUMN allowed_commands TEXT NOT NULL DEFAULT '[]';
diff --git a/crates/botloft-store/src/bots.rs b/crates/botloft-store/src/bots.rs
index a700139d..6b828252 100644
--- a/crates/botloft-store/src/bots.rs
+++ b/crates/botloft-store/src/bots.rs
@@ -21,6 +21,10 @@ pub struct BotRecord {
     pub paused: bool,
     pub permission_mode: PermissionMode,
     pub agent: AgentKind,
+    /// The model of a bot not on Claude Code; `None` for the default.
+    pub agent_model: Option<String>,
+    /// Command prefixes the bot may run without asking (spec 30).
+    pub allowed_commands: Vec<String>,
     pub model: BotModel,
     /// What Claude Code last reported; written by [`Store::set_model_in_use`]
     /// and left alone by [`Store::update_bot`].
@@ -34,7 +38,7 @@ pub struct BotRecord {
 }
 
 const COLUMNS: &str = "id, crew_id, name, handle, slug, role, instructions, color, paused, created_at, archived_at, \
-     permission_mode, model, model_in_use, effort, effort_default, agent";
+     permission_mode, model, model_in_use, effort, effort_default, agent, agent_model, allowed_commands";
 
 fn from_row(row: &Row<'_>) -> rusqlite::Result<BotRecord> {
     Ok(BotRecord {
@@ -58,16 +62,22 @@ fn from_row(row: &Row<'_>) -> rusqlite::Result<BotRecord> {
             .get::<_, Option<String>>(15)?
             .and_then(|level| level.parse().ok()),
         agent: parse_column(row, 16)?,
+        agent_model: row.get(17)?,
+        allowed_commands: serde_json::from_str(&row.get::<_, String>(18)?).unwrap_or_default(),
     })
 }
 
+fn commands_json(commands: &[String]) -> String {
+    serde_json::to_string(commands).unwrap_or_else(|_| "[]".to_owned())
+}
+
 impl Store {
     pub fn insert_bot(&self, bot: &BotRecord) -> Result<()> {
         self.conn
             .execute(
                 &format!(
                     "INSERT INTO bots ({COLUMNS}) \
-                     VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14, ?15, ?16, ?17)"
+                     VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13, ?14, ?15, ?16, ?17, ?18, ?19)"
                 ),
                 params![
                     bot.id.as_str(),
@@ -86,7 +96,9 @@ impl Store {
                     bot.model_in_use,
                     bot.effort.as_str(),
                     bot.effort_default.map(ModelEffort::as_str),
-                    bot.agent.as_str()
+                    bot.agent.as_str(),
+                    bot.agent_model,
+                    commands_json(&bot.allowed_commands)
                 ],
             )
             .map_err(|err| unique_as_duplicate(err, "bot handle or slug"))?;
@@ -155,7 +167,7 @@ impl Store {
             .execute(
                 "UPDATE bots SET name = ?2, handle = ?3, role = ?4, instructions = ?5, \
                  color = ?6, paused = ?7, archived_at = ?8, permission_mode = ?9, model = ?10, \
-                 effort = ?11 WHERE id = ?1",
+                 effort = ?11, agent_model = ?12, allowed_commands = ?13 WHERE id = ?1",
                 params![
                     bot.id.as_str(),
                     bot.name,
@@ -167,7 +179,9 @@ impl Store {
                     bot.archived_at,
                     bot.permission_mode.as_str(),
                     bot.model.as_str(),
-                    bot.effort.as_str()
+                    bot.effort.as_str(),
+                    bot.agent_model,
+                    commands_json(&bot.allowed_commands)
                 ],
             )
             .map_err(|err| unique_as_duplicate(err, "bot handle"))?;
diff --git a/crates/botloft-store/src/bots/tests.rs b/crates/botloft-store/src/bots/tests.rs
index 881777a8..95a74163 100644
--- a/crates/botloft-store/src/bots/tests.rs
+++ b/crates/botloft-store/src/bots/tests.rs
@@ -34,6 +34,8 @@ fn bot(crew: &CrewId, handle: &str, created_at: i64) -> BotRecord {
         paused: false,
         permission_mode: PermissionMode::Default,
         agent: AgentKind::Claude,
+        agent_model: None,
+        allowed_commands: Vec::new(),
         model: BotModel::Default,
         model_in_use: None,
         effort: BotEffort::Default,
diff --git a/crates/botloft-store/src/lib.rs b/crates/botloft-store/src/lib.rs
index acb3f08c..aadaf6cb 100644
--- a/crates/botloft-store/src/lib.rs
+++ b/crates/botloft-store/src/lib.rs
@@ -196,6 +196,8 @@ pub(crate) mod tests {
                         paused: false,
                         permission_mode: botloft_core::protocol::PermissionMode::Default,
                         agent: botloft_core::protocol::AgentKind::Claude,
+                        agent_model: None,
+                        allowed_commands: Vec::new(),
                         model: botloft_core::protocol::BotModel::Default,
                         model_in_use: None,
                         effort: botloft_core::protocol::BotEffort::Default,
diff --git a/crates/botloft-store/src/migrate.rs b/crates/botloft-store/src/migrate.rs
index dae21248..8bab9947 100644
--- a/crates/botloft-store/src/migrate.rs
+++ b/crates/botloft-store/src/migrate.rs
@@ -33,6 +33,11 @@ const MIGRATIONS: &[(u32, &str)] = &[
     (24, include_str!("../migrations/0024_mcp_servers.sql")),
     (25, include_str!("../migrations/0025_crew_color.sql")),
     (26, include_str!("../migrations/0026_bot_agent.sql")),
+    (27, include_str!("../migrations/0027_bot_agent_model.sql")),
+    (
+        28,
+        include_str!("../migrations/0028_bot_allowed_commands.sql"),
+    ),
 ];
 
 /// Schema version after every migration has run.
diff --git a/crates/botloftd/src/agent/agy.rs b/crates/botloftd/src/agent/agy.rs
index 87bf291e..0c4b6eaa 100644
--- a/crates/botloftd/src/agent/agy.rs
+++ b/crates/botloftd/src/agent/agy.rs
@@ -33,7 +33,7 @@ impl Agent for AgyAgent {
         AgentKind::Agy
     }
 
-    fn locate(&self, configured: &str, _claude: &Path) -> io::Result<PathBuf> {
+    fn locate(&self, configured: &str, _claude: Option<&Path>) -> io::Result<PathBuf> {
         let configured = configured.trim();
         if !configured.is_empty() {
             return Ok(PathBuf::from(configured));
@@ -76,6 +76,11 @@ impl Agent for AgyAgent {
         }
         args.push("--add-dir".into());
         args.push(plan.work_folder.as_os_str().to_owned());
+        // The effort is part of the model's id (`gemini-3.8-flash-low`).
+        if let Some(model) = plan.agent_model {
+            args.push("--model".into());
+            args.push(model.into());
+        }
         // `-p` takes the next argument as its prompt unless the value is
         // attached; there is none, the prompts come on stdin.
         args.push("-p=".into());
@@ -106,7 +111,10 @@ impl Agent for AgyAgent {
             },
         });
         std::fs::write(config.join("mcp_config.json"), pretty(&mcp))?;
-        std::fs::write(cli.join("settings.json"), pretty(&settings(files.fenced)))?;
+        std::fs::write(
+            cli.join("settings.json"),
+            pretty(&settings(files.fenced, files.allowed_commands)),
+        )?;
         // The rules `prepare_bot` wrote for Claude Code are the bot's rules;
         // `agy` reads `AGENTS.md` from its folder.
         let rules = files
@@ -127,20 +135,15 @@ impl Agent for AgyAgent {
     }
 
     fn encode_turn(&self, _uuid: &str, turn: &Turn) -> Bytes {
-        let mut content = vec![json!({ "type": "text", "text": turn.text })];
-        content.extend(turn.images.iter().map(|image| {
-            json!({
-                "type": "image",
-                "source": {
-                    "type": "base64",
-                    "media_type": image.media_type,
-                    "data": image.data,
-                },
-            })
-        }));
+        // The input takes text blocks only (a block of another type fails
+        // the turn, spec 30.4). An image reaches the bot as the path the
+        // courier lists in the text; the bot opens the file itself.
         let event = json!({
             "event": "user",
-            "message": { "role": "user", "content": content },
+            "message": {
+                "role": "user",
+                "content": [{ "type": "text", "text": turn.text }],
+            },
         });
         let mut line = event.to_string().into_bytes();
         line.push(b'\n');
@@ -167,16 +170,18 @@ fn rule_path(path: &Path) -> String {
 /// `settings.json` (spec 30.3): only Botloft's MCP tools run without asking,
 /// since in `-p` nothing can ask; whatever else needs a permission is denied
 /// by `agy` itself. Reads and writes of the fenced folders are denied.
-fn settings(fenced: &[PathBuf]) -> Value {
+fn settings(fenced: &[PathBuf], commands: &[String]) -> Value {
     let mut deny = Vec::new();
     for folder in fenced {
         let folder = rule_path(folder);
         deny.push(format!("read_file({folder})"));
         deny.push(format!("write_file({folder})"));
     }
+    let mut allow = vec!["mcp(botloft/*)".to_owned()];
+    allow.extend(commands.iter().map(|command| format!("command({command})")));
     json!({
         "permissions": {
-            "allow": ["mcp(botloft/*)"],
+            "allow": allow,
             "deny": deny,
         },
     })
@@ -187,6 +192,8 @@ fn settings(fenced: &[PathBuf]) -> Value {
 struct AgyDecoder {
     /// The reply text written so far in the current response.
     pending: String,
+    /// The model of this process, from `init`; sizes the context window.
+    model: String,
 }
 
 impl OutputDecoder for AgyDecoder {
@@ -209,6 +216,7 @@ impl OutputDecoder for AgyDecoder {
         match event["event"].as_str() {
             Some("init") => {
                 if let Some(model) = event["init"]["model"].as_str() {
+                    self.model = model.to_owned();
                     crate::service::models::reported(daemon, bot, model);
                 }
             }
@@ -237,7 +245,10 @@ impl AgyDecoder {
                     sink::message_read(daemon, bot, &uuid);
                 }
             }
-            (Some("agent_response"), Some("DONE")) => self.flush(daemon, bot),
+            (Some("agent_response"), Some("DONE")) => {
+                self.flush(daemon, bot);
+                self.context(daemon, bot, &update["usage"]);
+            }
             (Some("tool"), Some("ACTIVE")) => {
                 // What came before the tool is a reply of its own.
                 self.flush(daemon, bot);
@@ -282,6 +293,16 @@ impl AgyDecoder {
         sink::finish_turn(daemon, bot, generation, failed);
     }
 
+    /// What the last request held is what the conversation holds: its
+    /// prompt, cached or not, and what it wrote.
+    fn context(&self, daemon: &Daemon, bot: &BotId, usage: &Value) {
+        let count = |key: &str| usage[key].as_u64().unwrap_or_default();
+        let used = count("input_tokens") + count("cache_read_tokens") + count("output_tokens");
+        if used > 0 {
+            crate::context::report(daemon, bot, used, window_of(&self.model));
+        }
+    }
+
     /// The reply written so far becomes a chat item.
     fn flush(&mut self, daemon: &Daemon, bot: &BotId) {
         let text = std::mem::take(&mut self.pending);
@@ -289,6 +310,41 @@ impl AgyDecoder {
     }
 }
 
+/// How many tokens a conversation of `model` holds at most, by the family in
+/// its id: `agy` does not say (spec 30.4). A round figure, not a promise.
+fn window_of(model: &str) -> u64 {
+    if model.starts_with("gemini") {
+        1_000_000
+    } else if model.starts_with("claude") {
+        200_000
+    } else {
+        128_000
+    }
+}
+
+/// The models `agy models` lists: an id and a name for people, tab apart.
+pub fn models(program: &Path) -> io::Result<Vec<botloft_core::protocol::AgentModel>> {
+    let output = std::process::Command::new(program).arg("models").output()?;
+    if !output.status.success() {
+        return Err(io::Error::other("agy models failed"));
+    }
+    Ok(parse_models(&String::from_utf8_lossy(&output.stdout)))
+}
+
+fn parse_models(text: &str) -> Vec<botloft_core::protocol::AgentModel> {
+    text.lines()
+        .filter_map(|line| {
+            let (id, name) = line.split_once('\t')?;
+            let id = id.trim();
+            // The line "Fetching available models..." has no tab.
+            (!id.is_empty() && !id.contains(' ')).then(|| botloft_core::protocol::AgentModel {
+                id: id.to_owned(),
+                name: name.trim().to_owned(),
+            })
+        })
+        .collect()
+}
+
 /// An id for a tool step, unique among the bot's conversations.
 fn tool_id(conversation: &str, update: &Value) -> String {
     format!(
@@ -338,7 +394,7 @@ mod tests {
     use crate::agent::TurnImage;
 
     #[test]
-    fn a_turn_is_one_user_event_with_its_images() {
+    fn a_turn_is_one_user_event_with_text_only() {
         let turn = Turn {
             text: "hi".into(),
             images: vec![TurnImage {
@@ -352,7 +408,21 @@ mod tests {
         assert_eq!(json["event"], "user");
         assert_eq!(json["message"]["role"], "user");
         assert_eq!(json["message"]["content"][0]["text"], "hi");
-        assert_eq!(json["message"]["content"][1]["source"]["data"], "AAAA");
+        // An image block would fail the turn: `agy` takes text only.
+        assert_eq!(json["message"]["content"].as_array().map(Vec::len), Some(1));
+    }
+
+    #[test]
+    fn the_model_list_skips_the_line_that_is_not_one() {
+        let models = parse_models(
+            "Fetching available models...\ngemini-3.8-flash-low\tGemini 3.8 Flash (Low)\n\
+             claude-opus-5-5-high\tClaude Opus 5.5 (High)\n",
+        );
+        assert_eq!(models.len(), 2);
+        assert_eq!(models[0].id, "gemini-3.8-flash-low");
+        assert_eq!(models[1].name, "Claude Opus 5.5 (High)");
+        assert_eq!(window_of("gemini-3.8-flash-low"), 1_000_000);
+        assert_eq!(window_of("claude-opus-5-5-high"), 200_000);
     }
 
     #[test]
@@ -365,6 +435,7 @@ mod tests {
             permission_mode: botloft_core::protocol::PermissionMode::Default,
             model: botloft_core::protocol::BotModel::Default,
             effort: botloft_core::protocol::BotEffort::Default,
+            agent_model: Some("gemini-3.8-flash-low"),
         };
         let text = |args: Vec<OsString>| -> Vec<String> {
             args.into_iter()
@@ -374,6 +445,8 @@ mod tests {
         let fresh = text(AgyAgent.args(&plan(false)));
         assert!(!fresh.contains(&"--conversation".to_owned()));
         assert_eq!(fresh.last().map(String::as_str), Some("-p="));
+        let at = fresh.iter().position(|a| a == "--model").expect("model");
+        assert_eq!(fresh[at + 1], "gemini-3.8-flash-low");
         let resumed = text(AgyAgent.args(&plan(true)));
         let at = resumed
             .iter()
@@ -389,11 +462,12 @@ mod tests {
             "C:/Users/x/Botloft/a"
         );
         assert_eq!(rule_path(Path::new(r"\\?\C:\Users\x")), "C:/Users/x");
-        let settings = settings(&[PathBuf::from(r"C:\Data")]);
+        let settings = settings(&[PathBuf::from(r"C:\Data")], &["git status".to_owned()]);
         let deny = settings["permissions"]["deny"].as_array().expect("deny");
         assert!(deny.contains(&json!("write_file(C:/Data)")));
         assert!(deny.contains(&json!("read_file(C:/Data)")));
         assert_eq!(settings["permissions"]["allow"][0], "mcp(botloft/*)");
+        assert_eq!(settings["permissions"]["allow"][1], "command(git status)");
     }
 
     #[test]
diff --git a/crates/botloftd/src/agent/claude.rs b/crates/botloftd/src/agent/claude.rs
index ad0ce407..28e252a4 100644
--- a/crates/botloftd/src/agent/claude.rs
+++ b/crates/botloftd/src/agent/claude.rs
@@ -31,9 +31,11 @@ impl Agent for ClaudeAgent {
         AgentKind::Claude
     }
 
-    fn locate(&self, _configured: &str, claude: &Path) -> io::Result<PathBuf> {
+    fn locate(&self, _configured: &str, claude: Option<&Path>) -> io::Result<PathBuf> {
         // Found and checked by the supervisor, which keeps it up to date.
-        Ok(claude.to_path_buf())
+        claude
+            .map(Path::to_path_buf)
+            .ok_or_else(|| io::Error::new(io::ErrorKind::NotFound, "Claude Code was not found"))
     }
 
     fn args(&self, plan: &LaunchPlan<'_>) -> Vec<OsString> {
@@ -164,6 +166,7 @@ mod tests {
             permission_mode: PermissionMode::Default,
             model,
             effort,
+            agent_model: None,
         }
     }
 
diff --git a/crates/botloftd/src/agent/mod.rs b/crates/botloftd/src/agent/mod.rs
index 0dfcbf95..d261121a 100644
--- a/crates/botloftd/src/agent/mod.rs
+++ b/crates/botloftd/src/agent/mod.rs
@@ -15,7 +15,7 @@ use botloft_core::protocol::{AgentKind, BotEffort, BotModel, PermissionMode};
 use bytes::Bytes;
 use serde_json::Value;
 
-pub use agy::AgyAgent;
+pub use agy::{AgyAgent, models as agy_models};
 pub use claude::ClaudeAgent;
 
 use crate::state::Daemon;
@@ -48,6 +48,8 @@ pub struct LaunchPlan<'a> {
     pub permission_mode: PermissionMode,
     pub model: BotModel,
     pub effort: BotEffort,
+    /// The model of a bot not on Claude Code, as its agent names it.
+    pub agent_model: Option<&'a str>,
 }
 
 /// What an agent needs to write the files it reads at start, once the bot
@@ -58,6 +60,8 @@ pub struct LaunchFiles<'a> {
     pub token: &'a str,
     /// Folders the bot must not read or edit with its own tools (spec 7.5).
     pub fenced: &'a [PathBuf],
+    /// Command prefixes the owner lets the bot run without asking.
+    pub allowed_commands: &'a [String],
 }
 
 /// Reads one process's output, line by line (already JSON). One per process,
@@ -78,7 +82,8 @@ pub trait Agent: Send + Sync + 'static {
     fn kind(&self) -> AgentKind;
 
     /// The executable, from the configured path or the usual places.
-    fn locate(&self, configured: &str, claude: &Path) -> io::Result<PathBuf>;
+    /// `claude` is the Claude Code the supervisor found, when it found one.
+    fn locate(&self, configured: &str, claude: Option<&Path>) -> io::Result<PathBuf>;
 
     /// The arguments of the process, after the program.
     fn args(&self, plan: &LaunchPlan<'_>) -> Vec<OsString>;
diff --git a/crates/botloftd/src/context/mod.rs b/crates/botloftd/src/context/mod.rs
index 50284995..345d7e3c 100644
--- a/crates/botloftd/src/context/mod.rs
+++ b/crates/botloftd/src/context/mod.rs
@@ -139,6 +139,20 @@ pub(crate) fn answered(daemon: &Daemon, bot: &BotId, body: &Value) {
     });
 }
 
+/// An agent that is not Claude Code says how much its conversation holds
+/// (spec 30): the daemon does not ask it.
+pub(crate) fn report(daemon: &Daemon, bot: &BotId, used: u64, window: u64) {
+    let at = daemon.clock.now_ms();
+    update(daemon, bot, |entry| {
+        entry.size = Some(Size {
+            used,
+            window,
+            auto_compact: None,
+            at,
+        });
+    });
+}
+
 /// The usage of one model request in the bot's conversation: what it sent
 /// is what the conversation holds. Only moves a size that is known.
 pub(crate) fn used(daemon: &Daemon, bot: &BotId, message: &Value) {
diff --git a/crates/botloftd/src/rpc/dispatch.rs b/crates/botloftd/src/rpc/dispatch.rs
index 9cb6da7b..84738436 100644
--- a/crates/botloftd/src/rpc/dispatch.rs
+++ b/crates/botloftd/src/rpc/dispatch.rs
@@ -48,6 +48,8 @@ pub fn dispatch(daemon: &Daemon, name: &str, params: Option<Value>) -> Result<Va
             reply(modes::set_permission_mode(daemon, parse(params)?))
         }
         method::BOTS_SET_MODEL => reply(models::set_model(daemon, parse(params)?)),
+        method::BOTS_SET_AGENT_MODEL => reply(models::set_agent_model(daemon, parse(params)?)),
+        method::AGENTS_MODELS => reply(models::agent_models(daemon, parse(params)?)),
         method::BOTS_SET_EFFORT => reply(models::set_effort(daemon, parse(params)?)),
         method::BOTS_COMPACT => reply(crate::context::compact(daemon, parse(params)?)),
         method::BOTS_ARCHIVE => reply(bots::archive(daemon, parse(params)?)),
diff --git a/crates/botloftd/src/service/bots.rs b/crates/botloftd/src/service/bots.rs
index 4bc568e4..02c50ec1 100644
--- a/crates/botloftd/src/service/bots.rs
+++ b/crates/botloftd/src/service/bots.rs
@@ -120,6 +120,8 @@ pub(crate) fn insert(
         paused: false,
         permission_mode: PermissionMode::Default,
         agent: new.agent,
+        agent_model: None,
+        allowed_commands: Vec::new(),
         model: new.model,
         model_in_use: None,
         effort: new.effort,
@@ -151,11 +153,52 @@ pub fn update(daemon: &Daemon, params: BotsUpdateParams) -> ApiResult<Bot> {
     if let Some(color) = params.color {
         record.color = parse_color(&color)?;
     }
+    let mut commands_changed = false;
+    if let Some(commands) = params.allowed_commands {
+        if record.agent == AgentKind::Claude {
+            return Err(ApiError::validation(
+                "a Claude Code bot asks the owner; allowed_commands is for other agents",
+            ));
+        }
+        let commands = clean_commands(commands)?;
+        commands_changed = commands != record.allowed_commands;
+        record.allowed_commands = commands;
+    }
     // Rules first: if the disk write fails, nothing is saved. A running bot
     // reads them at its next start.
     super::mcp::write_rules(daemon, &store, &crew, &record).map_err(ApiError::Workspace)?;
     store.update_bot(&record)?;
-    Ok(changed(daemon, &store, &crew, record))
+    let id = record.id.clone();
+    let bot = changed(daemon, &store, &crew, record);
+    drop(store);
+    if commands_changed {
+        // The agent reads its rules when it starts.
+        daemon.supervisor.launch_settings_changed(&id);
+    }
+    Ok(bot)
+}
+
+/// The command prefixes as saved: trimmed, one line each, without repeats.
+fn clean_commands(commands: Vec<String>) -> ApiResult<Vec<String>> {
+    const MAX: usize = 50;
+    const LONGEST: usize = 200;
+    let mut clean: Vec<String> = Vec::new();
+    for command in commands {
+        let command = command.trim().to_owned();
+        if command.is_empty() || clean.contains(&command) {
+            continue;
+        }
+        if command.len() > LONGEST || command.contains(['\n', '\r', ')']) {
+            return Err(ApiError::validation(
+                "a command is one line of at most 200 characters, without a closing parenthesis",
+            ));
+        }
+        clean.push(command);
+    }
+    if clean.len() > MAX {
+        return Err(ApiError::validation("at most 50 commands"));
+    }
+    Ok(clean)
 }
 
 pub fn set_paused(daemon: &Daemon, params: BotsSetPausedParams) -> ApiResult<Bot> {
@@ -243,6 +286,8 @@ pub(crate) fn to_protocol(daemon: &Daemon, store: &Store, crew: &Crew, record: B
         paused: record.paused,
         permission_mode: record.permission_mode,
         agent: record.agent,
+        agent_model: record.agent_model,
+        allowed_commands: record.allowed_commands,
         model: record.model,
         model_in_use: record.model_in_use,
         effort: record.effort,
diff --git a/crates/botloftd/src/service/mod.rs b/crates/botloftd/src/service/mod.rs
index 994e35ab..fc0e5eed 100644
--- a/crates/botloftd/src/service/mod.rs
+++ b/crates/botloftd/src/service/mod.rs
@@ -32,7 +32,7 @@ pub mod settings;
 pub mod tasks;
 pub mod usage;
 
-use botloft_core::protocol::{OwnerAccount, PROTOCOL_VERSION, SystemStatus, error_code};
+use botloft_core::protocol::{AgentKind, OwnerAccount, PROTOCOL_VERSION, SystemStatus, error_code};
 use botloft_core::slug;
 use botloft_core::validate::ValidationError;
 use botloft_store::StoreError;
@@ -117,6 +117,10 @@ pub fn status(daemon: &Daemon) -> ApiResult<SystemStatus> {
         },
         deliveries,
         usage: daemon.usage(),
+        enabled_agents: [AgentKind::Claude, AgentKind::Agy, AgentKind::Codex]
+            .into_iter()
+            .filter(|kind| daemon.supervisor.agent_enabled(*kind))
+            .collect(),
     })
 }
 
diff --git a/crates/botloftd/src/service/models.rs b/crates/botloftd/src/service/models.rs
index f40a3941..8097b9c2 100644
--- a/crates/botloftd/src/service/models.rs
+++ b/crates/botloftd/src/service/models.rs
@@ -3,13 +3,14 @@
 
 use botloft_core::ids::BotId;
 use botloft_core::protocol::{
-    Bot, BotEffort, BotsSetEffortParams, BotsSetModelParams, ModelEffort,
+    AgentKind, AgentModel, AgentsModelsParams, Bot, BotEffort, BotsSetAgentModelParams,
+    BotsSetEffortParams, BotsSetModelParams, ModelEffort,
 };
 use serde_json::Value;
 use tracing::{info, warn};
 
-use super::ApiResult;
 use super::bots::{active, changed, to_protocol};
+use super::{ApiError, ApiResult};
 use crate::state::Daemon;
 
 /// Saves the model; the bot restarts on it when nothing is in progress.
@@ -105,3 +106,70 @@ pub(crate) fn applied(daemon: &Daemon, bot: &BotId, applied: &Value) {
     record.effort_default = default;
     changed(daemon, &store, &crew, record);
 }
+
+/// Saves the model of a bot that does not run on Claude Code; the bot
+/// restarts on it when nothing is in progress (spec 30).
+pub fn set_agent_model(daemon: &Daemon, params: BotsSetAgentModelParams) -> ApiResult<Bot> {
+    let store = daemon.store();
+    let (crew, mut record) = active(&store, &params.bot_id)?;
+    if record.agent == AgentKind::Claude {
+        return Err(ApiError::validation(
+            "a Claude Code bot's model is set with bots.setModel",
+        ));
+    }
+    let model = match params.model.as_deref().map(str::trim) {
+        None | Some("") => None,
+        Some(id) => {
+            let fine = id.len() <= 100
+                && id
+                    .chars()
+                    .all(|c| c.is_ascii_alphanumeric() || matches!(c, '.' | '-' | '_' | ':'));
+            if !fine {
+                return Err(ApiError::validation("model is not a model id"));
+            }
+            Some(id.to_owned())
+        }
+    };
+    if record.agent_model == model {
+        return Ok(to_protocol(daemon, &store, &crew, record));
+    }
+    record.agent_model = model;
+    store.update_bot(&record)?;
+    // What the agent reported belongs to the model it ran on.
+    store.set_effort_default(&record.id, None)?;
+    let bot = changed(daemon, &store, &crew, record);
+    drop(store);
+    info!(bot = %params.bot_id, "agent model changed");
+    daemon.supervisor.launch_settings_changed(&params.bot_id);
+    Ok(bot)
+}
+
+/// The models the agent offers, as it lists them. Kept for a while: asking
+/// takes seconds.
+pub fn agent_models(daemon: &Daemon, params: AgentsModelsParams) -> ApiResult<Vec<AgentModel>> {
+    use std::sync::Mutex;
+    use std::time::{Duration, Instant};
+    static CACHE: Mutex<Option<(Instant, Vec<AgentModel>)>> = Mutex::new(None);
+    if params.agent != AgentKind::Agy {
+        return Err(ApiError::validation(
+            "only agy lists its models; Claude Code's are fixed",
+        ));
+    }
+    let mut cache = CACHE
+        .lock()
+        .unwrap_or_else(|poisoned| poisoned.into_inner());
+    if let Some((at, models)) = cache.as_ref()
+        && at.elapsed() < Duration::from_secs(600)
+    {
+        return Ok(models.clone());
+    }
+    let agent = crate::agent::of(AgentKind::Agy)
+        .ok_or_else(|| ApiError::validation("agy is not available"))?;
+    let program = agent
+        .locate(daemon.supervisor.agy_path(), None)
+        .map_err(|err| ApiError::Conflict(err.to_string()))?;
+    let models = crate::agent::agy_models(&program)
+        .map_err(|err| ApiError::Conflict(format!("could not list the models: {err}")))?;
+    *cache = Some((Instant::now(), models.clone()));
+    Ok(models)
+}
diff --git a/crates/botloftd/src/supervisor/spawn.rs b/crates/botloftd/src/supervisor/spawn.rs
index 821b20bc..f70a498e 100644
--- a/crates/botloftd/src/supervisor/spawn.rs
+++ b/crates/botloftd/src/supervisor/spawn.rs
@@ -97,7 +97,7 @@ pub(super) fn launch_spec(
     daemon: &Daemon,
     crew: &Crew,
     bot: &BotRecord,
-    claude: &Claude,
+    claude: Option<&Claude>,
     session: Option<&str>,
 ) -> io::Result<(SpawnSpec, Launch)> {
     // settings.json and the rules are rewritten on every start.
@@ -116,7 +116,10 @@ pub(super) fn launch_spec(
     let agent = agent::of(bot.agent).ok_or_else(|| {
         io::Error::other(format!("bots on {} cannot start yet", bot.agent.as_str()))
     })?;
-    let program = agent.locate(daemon.supervisor.agy_path(), &claude.path)?;
+    let program = agent.locate(
+        daemon.supervisor.agy_path(),
+        claude.map(|claude| claude.path.as_path()),
+    )?;
     let mcp = workspace.join(".botloft").join("mcp.json");
     let work_folder = daemon.paths.work_folder(crew);
     let args = agent.args(&LaunchPlan {
@@ -127,6 +130,7 @@ pub(super) fn launch_spec(
         permission_mode: bot.permission_mode,
         model: bot.model,
         effort: bot.effort,
+        agent_model: bot.agent_model.as_deref(),
     });
 
     let mut env = platform::user_environment()?;
@@ -155,6 +159,7 @@ pub(super) fn launch_spec(
         port: daemon.port,
         token: &token,
         fenced: &fenced,
+        allowed_commands: &bot.allowed_commands,
     })?;
 
     // The values of the headers and variables of the bot's connected tools,
diff --git a/crates/botloftd/src/supervisor/start.rs b/crates/botloftd/src/supervisor/start.rs
index cb42a200..0da6228d 100644
--- a/crates/botloftd/src/supervisor/start.rs
+++ b/crates/botloftd/src/supervisor/start.rs
@@ -6,7 +6,7 @@
 use std::io;
 use std::sync::Arc;
 
-use botloft_core::protocol::{BotState, Crew};
+use botloft_core::protocol::{AgentKind, BotState, Crew};
 use botloft_store::BotRecord;
 use tokio::time::Instant;
 use tracing::{debug, warn};
@@ -25,7 +25,8 @@ use crate::state::Daemon;
 pub(super) struct Start {
     crew: Crew,
     bot: BotRecord,
-    claude: Claude,
+    /// Claude Code, for the bots that run on it; others start without.
+    claude: Option<Claude>,
     /// The conversation to resume; `None` starts a new one.
     session: Option<String>,
 }
@@ -46,9 +47,14 @@ impl Supervisor {
             ..
         } = inner;
         let slot = slots.get_mut(&bot.id)?;
-        let ClaudeStatus::Ready(claude) = claude else {
-            self.set_state(&bot.id, slot, BotState::Offline);
-            return None;
+        let claude = match claude {
+            ClaudeStatus::Ready(claude) => Some(claude.clone()),
+            // A bot on another agent does not need Claude Code (spec 30).
+            _ if bot.agent != AgentKind::Claude => None,
+            _ => {
+                self.set_state(&bot.id, slot, BotState::Offline);
+                return None;
+            }
         };
         slot.launching = true;
         // This start reads the bot's launch settings.
@@ -61,7 +67,7 @@ impl Supervisor {
         Some(Start {
             crew: crew.clone(),
             bot: bot.clone(),
-            claude: claude.clone(),
+            claude,
             session,
         })
     }
@@ -73,7 +79,7 @@ impl Supervisor {
             daemon,
             &start.crew,
             &start.bot,
-            &start.claude,
+            start.claude.as_ref(),
             start.session.as_deref(),
         )
         .and_then(|(spec, launch)| Ok((self.runtime.spawn(spec)?, launch)));
diff --git a/crates/botloftd/src/tools/bot_change.rs b/crates/botloftd/src/tools/bot_change.rs
index effa78d6..6aa5722c 100644
--- a/crates/botloftd/src/tools/bot_change.rs
+++ b/crates/botloftd/src/tools/bot_change.rs
@@ -197,6 +197,7 @@ fn apply(daemon: &Daemon, id: &BotId, before: &Profile, next: &Profile) -> ApiRe
             role: Some(next.role.clone()),
             instructions: Some(next.instructions.clone()),
             color: None,
+            allowed_commands: None,
         },
     )?;
     if next.model != before.model {
diff --git a/crates/botloftd/src/workspace/files.rs b/crates/botloftd/src/workspace/files.rs
index 4095c72f..c7d67bd9 100644
--- a/crates/botloftd/src/workspace/files.rs
+++ b/crates/botloftd/src/workspace/files.rs
@@ -311,6 +311,8 @@ mod tests {
             paused: false,
             permission_mode: botloft_core::protocol::PermissionMode::Default,
             agent: botloft_core::protocol::AgentKind::Claude,
+            agent_model: None,
+            allowed_commands: Vec::new(),
             model: botloft_core::protocol::BotModel::Default,
             model_in_use: None,
             effort: botloft_core::protocol::BotEffort::Default,
diff --git a/crates/botloftd/src/workspace/mod.rs b/crates/botloftd/src/workspace/mod.rs
index 0ecdf067..b05f07fd 100644
--- a/crates/botloftd/src/workspace/mod.rs
+++ b/crates/botloftd/src/workspace/mod.rs
@@ -161,6 +161,8 @@ mod tests {
             paused: false,
             permission_mode: botloft_core::protocol::PermissionMode::Default,
             agent: botloft_core::protocol::AgentKind::Claude,
+            agent_model: None,
+            allowed_commands: Vec::new(),
             model: botloft_core::protocol::BotModel::Default,
             model_in_use: None,
             effort: botloft_core::protocol::BotEffort::Default,
diff --git a/crates/botloftd/tests/agy_bot.rs b/crates/botloftd/tests/agy_bot.rs
index 742eb9c4..d082e1b4 100644
--- a/crates/botloftd/tests/agy_bot.rs
+++ b/crates/botloftd/tests/agy_bot.rs
@@ -335,3 +335,189 @@ async fn the_next_start_resumes_the_conversation() {
         .expect("resumed");
     assert_eq!(args[at + 1], "c-3");
 }
+
+#[tokio::test(start_paused = true)]
+async fn the_model_the_owner_picks_goes_to_the_next_process() {
+    let agy = agy_bot().await;
+    let first = agy.runtime.process(1).await;
+    agy.until(BotState::Idle).await;
+    assert!(!first.args().contains(&"--model".to_owned()));
+
+    let bot = botloftd::service::models::set_agent_model(
+        &agy.daemon,
+        botloft_core::protocol::BotsSetAgentModelParams {
+            bot_id: agy.bot.clone(),
+            model: Some("gemini-3.8-flash-high".into()),
+        },
+    )
+    .expect("model");
+    assert_eq!(bot.agent_model.as_deref(), Some("gemini-3.8-flash-high"));
+
+    let second = agy.runtime.process(2).await;
+    let args = second.args();
+    let at = args
+        .iter()
+        .position(|a| a == "--model")
+        .expect("model flag");
+    assert_eq!(args[at + 1], "gemini-3.8-flash-high");
+
+    // Not a model id.
+    let refused = botloftd::service::models::set_agent_model(
+        &agy.daemon,
+        botloft_core::protocol::BotsSetAgentModelParams {
+            bot_id: agy.bot.clone(),
+            model: Some("bad id; rm".into()),
+        },
+    );
+    assert!(refused.is_err());
+}
+
+#[tokio::test(start_paused = true)]
+async fn the_usage_of_a_response_is_how_full_the_conversation_is() {
+    let agy = agy_bot().await;
+    let process = agy.runtime.process(1).await;
+    agy.until(BotState::Idle).await;
+    assert!(agy.daemon.contexts.get(&agy.bot).is_none());
+
+    agy.daemon
+        .supervisor
+        .write_message(&agy.bot, "u-1", "{}\n".into())
+        .expect("running");
+    process
+        .emit(json!({ "event": "init", "init": { "conversation_id": "c-9", "model": "gemini-3.8-flash-low" } }))
+        .await;
+    process
+        .emit(step("c-9", 0, "user_input", "DONE", json!({})))
+        .await;
+    process
+        .emit(step(
+            "c-9",
+            1,
+            "agent_response",
+            "DONE",
+            json!({ "usage": { "input_tokens": 1000, "cache_read_tokens": 500, "output_tokens": 50 } }),
+        ))
+        .await;
+    process
+        .emit(json!({ "event": "result", "result": { "status": "SUCCESS", "duration_seconds": 0.1, "usage": {} } }))
+        .await;
+    agy.until(BotState::Idle).await;
+
+    let context = agy.daemon.contexts.get(&agy.bot).expect("known now");
+    assert_eq!(context.used_tokens, 1550);
+    assert_eq!(context.window_tokens, 1_000_000);
+    assert_eq!(context.auto_compact_tokens, None);
+}
+
+#[tokio::test(start_paused = true)]
+async fn an_agy_bot_starts_without_claude_code_and_a_claude_bot_stays_offline() {
+    let mut settings = test_settings();
+    settings.claude = botloftd::supervisor::ClaudeSource::Discover {
+        configured: r"C:\no\such\claude.exe".to_owned(),
+    };
+    settings.experimental_agents = vec!["agy".to_owned()];
+    settings.agy_path = r"C:\Agy\agy.exe".to_owned();
+    let parts = new_daemon(settings);
+    let crew = crews::create(
+        &parts.daemon,
+        CrewsCreateParams {
+            name: "Ops".into(),
+            work_folder: None,
+            lead: None,
+        },
+    )
+    .expect("crew");
+    let make = |name: &str, agent| {
+        bots::create(
+            &parts.daemon,
+            BotsCreateParams {
+                crew_id: crew.id.clone(),
+                name: name.into(),
+                role: String::new(),
+                instructions: String::new(),
+                color: None,
+                model: None,
+                agent,
+            },
+        )
+        .expect("bot")
+    };
+    let claude = make("Claude bot", None);
+    let agy = make("Agy bot", Some(AgentKind::Agy));
+    tokio::spawn(supervisor::run(Arc::clone(&parts.daemon)));
+
+    // Its process is up although Claude Code was never found.
+    let _process = parts.runtime.process(1).await;
+    for _ in 0..600 {
+        if parts.daemon.supervisor.status(&agy.id).map(|(s, _)| s) == Some(BotState::Idle) {
+            break;
+        }
+        tokio::time::sleep(Duration::from_millis(10)).await;
+    }
+    assert_eq!(
+        parts.daemon.supervisor.status(&agy.id).map(|(s, _)| s),
+        Some(BotState::Idle)
+    );
+    assert_eq!(
+        parts.daemon.supervisor.status(&claude.id).map(|(s, _)| s),
+        Some(BotState::Offline)
+    );
+}
+
+#[tokio::test(start_paused = true)]
+async fn the_commands_the_owner_allows_reach_the_rules_of_the_next_process() {
+    let agy = agy_bot().await;
+    let first = agy.runtime.process(1).await;
+    agy.until(BotState::Idle).await;
+    let settings_path = first
+        .spec
+        .cwd
+        .join(".botloft/agy-home/.gemini/antigravity-cli/settings.json");
+    let before: Value =
+        serde_json::from_str(&std::fs::read_to_string(&settings_path).expect("file"))
+            .expect("json");
+    assert_eq!(
+        before["permissions"]["allow"].as_array().map(Vec::len),
+        Some(1)
+    );
+
+    let bot = bots::update(
+        &agy.daemon,
+        botloft_core::protocol::BotsUpdateParams {
+            bot_id: agy.bot.clone(),
+            name: None,
+            role: None,
+            instructions: None,
+            color: None,
+            allowed_commands: Some(vec![
+                " git status ".into(),
+                "npm test".into(),
+                "git status".into(),
+            ]),
+        },
+    )
+    .expect("update");
+    assert_eq!(bot.allowed_commands, ["git status", "npm test"]);
+
+    let _second = agy.runtime.process(2).await;
+    let after: Value =
+        serde_json::from_str(&std::fs::read_to_string(&settings_path).expect("file"))
+            .expect("json");
+    let allow = after["permissions"]["allow"].as_array().expect("allow");
+    assert!(allow.contains(&json!("command(git status)")));
+    assert!(allow.contains(&json!("command(npm test)")));
+
+    // A line or a closing parenthesis would break the rule it goes into.
+    let refused = bots::update(
+        &agy.daemon,
+        botloft_core::protocol::BotsUpdateParams {
+            bot_id: agy.bot.clone(),
+            name: None,
+            role: None,
+            instructions: None,
+            color: None,
+            allowed_commands: Some(vec!["a) b".into()]),
+        },
+    );
+    assert!(refused.is_err());
+}
diff --git a/docs/spec.md b/docs/spec.md
index 60f42d13..4e7f81e4 100644
--- a/docs/spec.md
+++ b/docs/spec.md
@@ -679,7 +679,7 @@ Endpoint: `ws://127.0.0.1:45710/rpc`. Mensagens seguem JSON-RPC 2.0: requests co
 
 | Método | Params | Result |
 |---|---|---|
-| `system.status` | | versão, uptime, versão e caminho do claude (`claudeVersion`, `claudePath`), `runtimeError` (por que os bots não sobem), `claudeSignedIn` (7.3; `null` antes de conferir), `account` (o dono para a área da conta do app: `name`, o nome de exibição da conta do Windows, `GetUserNameExW(NameDisplay)`, ou o nome de usuário sem ele, lido uma vez; e `claude`, a conta do Claude com `email`, `plan` e `organization`, ou `null` desconectado), backlog de entrega, `usage` (uso da conta, 8.1) |
+| `system.status` | | versão, uptime, `enabledAgents` (os agentes para os quais um bot pode ser criado: `claude` e os experimentais ligados, seção 30), versão e caminho do claude (`claudeVersion`, `claudePath`), `runtimeError` (por que os bots não sobem), `claudeSignedIn` (7.3; `null` antes de conferir), `account` (o dono para a área da conta do app: `name`, o nome de exibição da conta do Windows, `GetUserNameExW(NameDisplay)`, ou o nome de usuário sem ele, lido uma vez; e `claude`, a conta do Claude com `email`, `plan` e `organization`, ou `null` desconectado), backlog de entrega, `usage` (uso da conta, 8.1) |
 | `system.refresh` | | pede uma nova conferência do Claude Code (login e, se falhou, o executável) e responde na hora com o `system.status` atual; o app relê o status até ver o resultado |
 | `crews.list` | | `Crew[]` |
 | `crews.create` | `name, workFolder?, lead?` (`{name, role, instructions, model?}`: o chefe, 10.2) | `Crew` |
@@ -692,11 +692,13 @@ Endpoint: `ws://127.0.0.1:45710/rpc`. Mensagens seguem JSON-RPC 2.0: requests co
 | `crews.delete` | `crewId, recycleFolder?` | `{crewId}`; exclui a crew, ativa ou arquivada, com todos os bots dela; com `recycleFolder`, a pasta dela vai depois para a Lixeira (7.6) |
 | `bots.list` | `crewId?` | `Bot[]` |
 | `archive.list` | | `{crews, bots}`: o que está arquivado, que `crews.list` e `bots.list` deixam de fora, do arquivado mais recente ao mais antigo. `bots` traz todos os bots arquivados, também os das crews arquivadas (7.6) |
+| `bots.setAgentModel` | `botId, model` (um id de `agents.models`, ou `null` para o padrão do agente) | `Bot`; o bot reinicia quando nada estiver em andamento (30.3) |
+| `agents.models` | `agent` | `{id, name}[]` com o que o agente lista (`agy models`); guardado por 10 minutos |
 | `bots.create` | `crewId, name, role, instructions, color?, model?, agent?` | `Bot` (`agent` é `claude`, `codex` ou `agy`; só `claude` roda por enquanto, os outros dão `-32004`: seção 30) |
 | `catalog.list` | `category?` | `BotTemplate[]`: os modelos de bot do catálogo, sem as instruções (26.4) |
 | `catalog.get` | `id` | `BotTemplateFull`: o modelo com `instructions`, `model` e `effort` (26.4) |
 | `catalog.add` | `crewId, templateId, name, role` | `Bot`: cria na equipe um bot a partir do modelo (26.4) |
-| `bots.update` | `botId, name?, role?, instructions?, color?` | `Bot` |
+| `bots.update` | `botId, name?, role?, instructions?, color?, allowedCommands?` | `Bot` (`allowedCommands` só para bots que não são Claude, 30.3) |
 | `bots.setPaused` | `botId, paused` | `Bot` |
 | `bots.setPermissionMode` | `botId, mode` (`default`, `accept_edits`, `plan`, `auto`, `bypass_permissions`) | `Bot`; o bot reinicia no novo modo quando nada estiver em andamento (7.4) |
 | `bots.setModel` | `botId, model` (`default`, `fable`, `opus`, `sonnet`, `haiku`) | `Bot`; o bot reinicia no novo modelo quando nada estiver em andamento (7.4) |
@@ -756,7 +758,7 @@ Pragmas: `journal_mode=WAL`, `synchronous=NORMAL`, `foreign_keys=ON`, `busy_time
 | Tabela | Colunas principais |
 |---|---|
 | `crews` | `id, name, slug, paused, work_dir, lead_bot_id, color, created_at, archived_at` (`work_dir` é a pasta escolhida; `NULL` usa a `shared`. `lead_bot_id` é o chefe, sem chave estrangeira: ele é gravado junto com a crew. `color` é o `#RRGGBB` que o dono escolheu, `NULL` sem cor) |
-| `bots` | `id, crew_id, name, handle, slug, role, instructions, color, paused, permission_mode, agent, model, model_in_use, effort, effort_default, token_hash, session_id, created_at, archived_at` (`effort_default` é o nível do próprio modelo, como o Claude Code disse: `low` a `max`, `none` ou `NULL`, 7.4) |
+| `bots` | `id, crew_id, name, handle, slug, role, instructions, color, paused, permission_mode, agent, agent_model, model, model_in_use, effort, effort_default, token_hash, session_id, created_at, archived_at` (`effort_default` é o nível do próprio modelo, como o Claude Code disse: `low` a `max`, `none` ou `NULL`, 7.4) |
 | `messages` | `id, crew_id, from_kind (owner/bot/system), from_bot_id, to_bot_id, kind (note/task/result/system), body, task_id, created_at`; `reply_item_id` e `reply_text` quando o dono respondeu a algo do chat (9.3; sem chave estrangeira, porque os itens saem antes das messages na exclusão, 7.6) |
 | `attachments` | `id, message_id, name, media_type, size, path, created_at` |
 | `deliveries` | `id, message_id, bot_id, state, attempts, next_attempt_at, lease_until, last_error, sent_generation, turn_uuid, read_at, updated_at` |
@@ -2648,7 +2650,8 @@ Decisão e contexto: `docs/adr/0003-agentes.md`. Um bot tem um **agente**, `Bot.
 | **A1** | A interface `Agent` no daemon (`crates/botloftd/src/agent`), com o Claude por trás e os testes de hoje sem mudança. Em fatias: **A1a** argumentos do processo, ambiente extra e codificação do turno no stdin (feito); **A1b** leitura da saída: cada agente decodifica o próprio fluxo (`Agent::handle_output`, `Agent::live_text`) e grava no chat por `chat::sink` (resposta, ferramenta que começa e termina, fim de turno), o que todo agente tem; o que é só do Claude (contexto, compactação, parte do plano, rascunho de telas) fica no decodificador dele, `chat/claude.rs` (feito); **A1c** descoberta e login, arquivos da pasta do bot e aprovações | em andamento |
 | **A2** | AGY, **experimental**: só existe quando `experimental_agents = ["agy"]` no `config.toml`. Lançamento, entrada e saída, MCP do Botloft, isolamento por regras `deny`, retomada de conversa, no `agy` real. Sem aprovações do dono e sem comandos de shell (30.3); sem modelo e esforço escolhidos, contexto, compactação nem ferramentas conectadas do dono | feito (sem seletor no app) |
 | **A3** | Codex por `codex app-server` | a fazer |
-| **A4** | Seletor de agente no app, conta e login de cada agente, paridade de rotinas, navegador, desktop e perguntas | a fazer |
+| **A5** | **Lacunas do AGY**: comandos liberados por bot, bot AGY sobe sem o Claude Code, retomada conferida com o `agy` real (30.3, 30.4) | feito |
+| **A4** | Seletor de agente no app (**feito**: na criação do bot, aparece quando há mais de um agente em `enabledAgents`, com o aviso de experimental e sem a escolha de modelo; o medidor de contexto, o esforço e o modelo do campo de mensagem só aparecem para bots Claude). **Falta:** conta e login de cada agente, paridade de rotinas, navegador, desktop e perguntas | em andamento |
 
 ### 30.2 O que a interface `Agent` possui
 
@@ -2660,7 +2663,12 @@ Descoberta e saúde (binário, versão mínima, login, comando de entrar); lanç
 - **Casa própria:** o processo roda com `USERPROFILE` e `HOME` em `<pasta do bot>\.botloft\agy-home`. Lá o Botloft escreve a cada start `.gemini/config/mcp_config.json` (o servidor `botloft`, com o token do bot no cabeçalho) e `.gemini/antigravity-cli/settings.json`. Assim o `GEMINI.md`, os servidores MCP e as configurações pessoais do dono ficam de fora (o login não mora ali e continua valendo).
 - **Regras do bot:** o texto que o Claude lê em `.claude/rules/botloft.md` é copiado para `AGENTS.md` na pasta do bot, que o `agy` carrega.
 - **Permissões:** em `-p` o `agy` não pergunta nada (30.4), então o Botloft decide de antemão: `allow` só `mcp(botloft/*)`; `deny` de `read_file(<pasta>)` e `write_file(<pasta>)` para cada pasta cercada (a mesma lista da seção 7.5: dados do Botloft e pastas de outras crews). Comandos de shell são negados pelo próprio `agy`, e o `result` traz `denied_actions`. O dono ainda não tem como liberar um comando.
-- **Não faz:** pedidos de controle (`get_settings`, `get_context_usage`, `mcp_status`, `/compact`): o `agy` recusa o formato; por isso o medidor de contexto e "Compactar" não existem para esses bots. Também não há cartão de plano, uso do plano nem ferramentas conectadas do dono.
+- **Comandos liberados:** `Bot.allowedCommands` (`bots.allowed_commands`, migration 0028; `bots.update { allowedCommands }`, só para bots que não são Claude) são prefixos de comando que o dono libera. Entram no `settings.json` do bot como `allow` `command(<prefixo>)`; o `agy` casa palavra por palavra, então `git status` libera `git status -s`. Um `*` libera tudo, e o diálogo avisa. Fora da lista, o `agy` nega sozinho e o chat mostra a ferramenta falhada com o comando. Mudou a lista, o bot reinicia quando nada estiver em andamento. Cada item tem uma linha, até 200 caracteres, sem `)`; até 50 itens.
+- **Sem o Claude Code:** um bot que não roda nele sobe mesmo sem o Claude Code instalado; o supervisor só o exige dos bots Claude. O app mostra o aviso "bots não sobem" e o de login do Claude só quando há um bot Claude (ou nenhum bot ainda).
+- **Modelo:** `Bot.agentModel` (`bots.agent_model`, migration 0027) é um id de `agy models`, passado como `--model`; o esforço faz parte do id (`...-high`), então não há seletor de esforço. O app lista os modelos por `agents.models` e troca por `bots.setAgentModel`.
+- **Contexto:** o `agy` não responde ao pedido de uso. O Botloft usa o `usage` do último `step_update` de resposta (`input_tokens + cache_read_tokens + output_tokens`) como o que a conversa guarda, e a janela vem da família do modelo (`gemini` 1.000.000, `claude` 200.000, outros 128.000): é uma estimativa e o painel diz isso. Não há compactação nem limite para compactar sozinho.
+- **Imagens:** a entrada do `agy` só aceita blocos de texto (outro tipo falha o turno inteiro). A imagem anexada vai como o caminho que o courier já lista no texto, e o bot a abre com `view_file`.
+- **Não faz:** pedidos de controle (`get_settings`, `get_context_usage`, `mcp_status`, `/compact`): o `agy` recusa o formato; por isso "Compactar" não existe para esses bots. Também não há cartão de plano, uso do plano nem ferramentas conectadas do dono.
 - **Eventos:** `init` dá o modelo; `step_update` `user_input` `DONE` é o recibo de leitura da mensagem mais antiga escrita (o `agy` não devolve o id) e grava a conversa a retomar (`--conversation`); `agent_response` `ACTIVE` é o texto ao vivo e `DONE` fecha a resposta; `tool` `ACTIVE`, `DONE` e `ERROR` são a ferramenta (`write_to_file`, `run_command`, `view_file`... aparecem como `Write`, `Bash`, `Read`); `result` fecha o turno, com `usage` e `status`.
 
 ### 30.3.1 Isolamento dos agentes
@@ -2679,8 +2687,11 @@ Um agente só roda bots quando o Botloft impõe o que a seção 7.5 impõe no Cl
 | `agy`: isolamento | `--sandbox` **não** impediu a escrita fora da pasta (só restringe o terminal). O agente carrega `~/.gemini/GEMINI.md` do dono (memória pessoal, 24 KB aqui) e usa `~/.gemini/antigravity-cli/settings.json`; o MCP fica em `~/.gemini/config/mcp_config.json`. **`USERPROFILE` muda essa pasta** e o login sobrevive; sem o `GEMINI.md` do dono o prefixo `[MAHI68]` some. Regras `permissions` no `settings.json`: `command(echo hello)` em `allow` funcionou; `write_file(C:/pasta/completa)` em `deny` bloqueia a escrita ali (letra do drive, barras normais, sem curinga; `/**`, `/*` e o caminho sem o drive **não** casaram; `write_file(*)` bloqueia tudo). Ação e alvos conforme `antigravity.google/docs/permissions` | feito: 1.3.1. Na pasta de um daemon real, um bot não leu o `owner.token` (fechou em `DENIED`) |
 | `agy`: instruções da pasta | `AGENTS.md` e `GEMINI.md` na pasta de trabalho são lidos; `.claude/rules/*.md` e `.agents/rules/*.md` **não** | feito: 1.3.1 |
 | `agy`: MCP por HTTP | `agy mcp add --header "K: V" <nome> <url>` grava `{"mcpServers":{"<nome>":{"disabled":false,"headers":{...},"serverUrl":"<url>"}}}` em `~/.gemini/config/mcp_config.json`. **Testado com o daemon real**: o bot listou as ferramentas do servidor `botloft` (`send_message`, `complete_task`, `ask_owner`...) com `allow` `mcp(botloft/*)` | feito: 1.3.1 |
+| `agy`: imagem na entrada | Um bloco `image` (formato do Claude, `mime_type`/`data`, `inline_data` ou `image_url`) falha o turno: `stream input content block type "image" is not supported (only "text")`. Com o arquivo na pasta e o caminho no texto, o bot abriu a imagem com `view_file` e respondeu a cor certa | feito: 1.3.1 |
+| `agy`: uso e contexto | O `usage` de cada `step_update` de resposta traz `input_tokens`, `cache_read_tokens`, `output_tokens` e `thinking_tokens`; o do `result` é a soma dos passos do turno. Não há tamanho de janela em `agy models` (só `id<TAB>nome`) | feito: 1.3.1 |
 | `agy`: pedido de controle de outro formato | Uma linha `{"type":"control_request",...}` no stdin vira um turno com erro: `stream input message is missing the "event" field` (visto no daemon real antes de o Botloft parar de enviá-la) | feito: 1.3.1 |
-| `agy`: `--conversation`, `--add-dir` | Passados no lançamento e cobertos por teste com o `FakeRuntime`; a retomada **não** foi vista com o `agy` real | a fazer |
+| `agy`: `--conversation` | **Testado com 1.3.1**, mesma casa (`USERPROFILE`) nos dois processos: a segunda execução com o id da primeira lembrou a palavra combinada; sem o id, uma conversa nova não lembrou. Com um id que não existe, o `agy` imprime `warning: conversation "<id>" not found` (linha que não é JSON) e **segue numa conversa nova**, que o Botloft grava no primeiro `user_input` | feito: 1.3.1 |
+| `agy`: `conversation_id` | Vem no nível de cima do `init` (`{"event":"init","conversation_id":...,"init":{...}}`) e em cada `step_update` | feito: 1.3.1 |
 | `agy`: erros de login, limite de uso | **Não visto**: um bot sem login ou no limite aparece como turno com erro | a fazer |
 | `agy models` | Lista `gemini-3.8-flash-{high,medium,low}`, `gemini-3.7-...`, `gemini-3.1-pro-{high,low}` e `claude-opus-5-5-{low,medium,high}`, entre outros: o nível de esforço faz parte do id do modelo | feito |
 | `codex` 0.148.0-alpha.9: `exec --json` | Um turno por processo: `thread.started`, `turn.started`, `item.completed` (`agent_message`), `turn.completed` com `usage` (`input_tokens`, `cached_input_tokens`, `output_tokens`, `reasoning_output_tokens`). Não serve para um bot que fica ligado | feito: um turno, `read-only` |