diff --git a/lat.md/lat.md b/lat.md/lat.md
index 3e103331d..8c1635da7 100644
--- a/lat.md/lat.md
+++ b/lat.md/lat.md
@@ -25,4 +25,5 @@ This directory defines the high-level concepts, business logic, and architecture
 - [[office-3d-interiors]] — enterable office/bank/showroom interiors: per-location conditional mounting (city unmounts while indoors), camera fly-in rig, interactable objects (ATM → wallet, desk → agent, car → spec card), and idle-agent walking trips between buildings.
 - [[office-3d-walk-mode]] — GTA-style walk mode: glass roofs over the enterable buildings, the user's own third-person avatar (WASD + chase camera, shared crowd/collision), doorway-driven interior loading, and proximity Press-E interactions.
 - [[office-interactions]] — space representatives: interactive bank tellers whose menu runs account status, balances, and account creation against the hermes-one backend for a chosen agent; the extensible pattern for future spaces (showroom sales, building space).
+- [[office-world-actions]] — chat-commanded errands: the agent's LLM emits world-action blocks from the office chat, its avatar walks the trip route to the bank/showroom, and the rep modal auto-opens running the requested action on arrival.
 - [[mcp-servers]] — add / edit / remove / enable / test MCP servers from the Capabilities → MCP tab; the shared add+edit modal and the in-place atomic `updateMcpServer` upsert (config.yaml locally, gateway REST in Remote/SSH).
diff --git a/lat.md/office-3d-interiors.md b/lat.md/office-3d-interiors.md
index 0f865b947..2c21d8771 100644
--- a/lat.md/office-3d-interiors.md
+++ b/lat.md/office-3d-interiors.md
@@ -56,6 +56,8 @@ Everything lives in [[src/renderer/src/screens/Office/office3d/core/collision.ts
 
 Blocked walkers wall-follow: when the push-out cancels a step, the walker commits to a short slide along the blocking face's tangent — signed toward its goal, re-derived at corners — with goal steering suspended for the burst. (A per-frame perpendicular nudge is not enough: the goal pull re-pins the walker against the face each frame, walking in place forever — the original stuck-at-desk bug.) The static resolver exposes its push normal for this via `resolveStaticColliders`' `pushOut`.
 
+Wall-follow handles convex obstacles only — in a concave pocket (a wall corner plus furniture) the two faces re-derive opposite slides every frame and the walker deadlocks in place. Doorways are therefore routed explicitly: [[src/renderer/src/screens/Office/office3d/core/routing.ts#routeTarget]] makes every room crossing a two-hop "door gate" (near-side gate point first, then the far side), so the wall-crossing hop passes through the door gap from any start position. The CEO office's own doorway is routed before the divider — a CEO→east walk that aims at the partition door first pins against the glass (the stuck-in-the-corner bug, exposed when [[office-world-actions|chat-commanded missions]] started walks from arbitrary desks). [[src/renderer/src/screens/Office/office3d/core/routing.test.ts]] walks the previously-deadlocking routes hop by hop and asserts no hop segment crosses an interior wall.
+
 Desk seats add a structural rule: agents approach the chair from the open side — up the desk-free aisle between desk columns, then across at seat height (`deskApproachByAgent` in AgentsLayer) — so the everyday sit-down never depends on obstacle avoidance at all. Trip/NPC waypoints sit clear of all colliders with looser arrival radii so a crowded waypoint can't strand anyone. Pedestrians register in the same crowd as visiting agents, so the two populations avoid each other too; standing staff participate as static circles.
 
 ## Agent trips
@@ -64,6 +66,6 @@ Idle agents occasionally walk out of the office to the bank or showroom, wander
 
 The canvas↔world mapping ([[src/renderer/src/screens/Office/office3d/core/geometry.ts#worldToCanvas]]) is linear, so waypoints far outside the office's 0..1800 rectangle work unchanged — no second coordinate system.
 
-The controller in [[src/renderer/src/screens/Office/office3d/objects/AgentsLayer.tsx#AgentsLayer]] adds a "trip" mode (phases out → wander → back) beside toSeat/seated. Only idle (non-working) seated agents start trips, capped at `TRIP_MAX_TRAVELLERS`; if an agent's gateway starts mid-trip it walks the route home in reverse rather than teleporting. Each agent's `place` ("office" | "bank" | "showroom" | "outside") is derived from route progress.
+The controller in [[src/renderer/src/screens/Office/office3d/objects/AgentsLayer.tsx#AgentsLayer]] adds a "trip" mode (phases out → wander → back) beside toSeat/seated. Only idle (non-working) seated agents start trips, capped at `TRIP_MAX_TRAVELLERS`; if an agent's gateway starts mid-trip it walks the route home in reverse rather than teleporting. Each agent's `place` ("office" | "bank" | "showroom" | "outside") is derived from route progress. Trips can also be commanded from the office chat — a mission replaces the wander with a "visit" at a named interaction stop; see [[office-world-actions#Office World Actions#Commanded trips]].
 
 The simulation always runs for every agent; the `visiblePlace` prop only toggles per-agent wrapper-group visibility each frame, so each interior view shows exactly the agents actually in that building and the city view shows everyone, including walkers on the street.
diff --git a/lat.md/office-interactions.md b/lat.md/office-interactions.md
index 48f588151..2b36e3bc8 100644
--- a/lat.md/office-interactions.md
+++ b/lat.md/office-interactions.md
@@ -2,7 +2,7 @@
 
 Interactables in the Office tab's bank that agents do business with. Clicking the bank teller or the self-service ATM opens a shared action modal (balances, account status, and more) run against the hermes-one backend for the chosen agent.
 
-The bank is the first transaction space; future spaces (car showroom sales, building space) reuse the same pieces: a registry entry, an [[src/renderer/src/screens/Office/office3d/objects/Interactable.tsx#Interactable]] hookup in the interior, and action wiring in the panel. Coming-soon actions (the ATM's withdraw/deposit) are registered with a `disabled` flag and render as muted "Soon" chips until their flows land.
+The bank is the first transaction space; future spaces (car showroom sales, building space) reuse the same pieces: a registry entry, an [[src/renderer/src/screens/Office/office3d/objects/Interactable.tsx#Interactable]] hookup in the interior, and action wiring in the panel. Coming-soon actions (the ATM's withdraw/deposit) are registered with a `disabled` flag and render as muted "Soon" chips until their flows land. Beyond clicking, the panel can also be opened by an agent itself: a chat-commanded errand walks the agent to the rep and auto-opens the panel with the requested action — see [[office-world-actions]].
 
 ## Representative Registry
 
@@ -22,6 +22,8 @@ A centered modal shared by every representative (bank teller, ATM): a dimmed bac
 
 [[src/renderer/src/screens/Office/RepInteractionPanel.tsx#RepInteractionPanel]] takes the rep, the agent list, and an initial agent. Office passes `selectedId ?? defaultAgentId`, where `defaultAgentId` is the active profile (the `profile` prop, matched by agent id) or the first agent — so the picker opens pre-selected on the current profile instead of an empty "Choose an agent…". It renders a fixed inset-0 backdrop (dismiss on backdrop click or Escape) centering the card; the card fades/scales in on mount and its layout is self-contained inline styles (not Tailwind classes) so positioning can't break. The header identity is per-representative: a `REP_ICONS` glyph (bank landmark for the teller, card for the ATM), the rep's name, a live status line with a green dot (teller "Open · serving {agent}", ATM "Online · {agent}") and an agent-picker chip (an avatar + native `<select>` so it stays keyboard-accessible). A hero card morphs with the latest action outcome — total-balance figure with a decorative flat sparkline ([[src/renderer/src/screens/Office/RepInteractionPanel.tsx#BalanceSparkline]], carries no data since the backend has no price history), a loading skeleton, a success card (address · Base), an error card with a **Retry** button that re-runs the last action, a warning hint, or the dedicated empty-wallet card (`$0.00`, "no funds in this account yet" — no create prompt, since reaching a balance means the account exists) when a loaded balance is zero. Below it, token rows (round symbol badge, name, amount, USD) render on a loaded balance and account-status rows render transactable/receive-only badges. Money figures (the total, token amounts, and USD values) render in Space Grotesk via the `--font-numeric` token — a self-hosted `@font-face` in `src/renderer/src/assets/main.css` (`fonts/SpaceGrotesk-Variable.ttf`), no CDN.
 
+A mission-driven open (see [[office-world-actions#Office World Actions#Orchestration]]) passes `autoAction`, which the panel runs exactly once after the account scope resolves — the `accountResolved` gate exists because the accountId resolution changes the cache key, bumps `requestSeq`, and would drop an action fired at mount.
+
 Actions render as flex-wrapping chips (`visibleActions`) rather than a fixed grid, so a variable set always lays out cleanly with no empty cells: **check balance** (primary/accent chip) reads the cached transactable wallet id when present — otherwise looks it up via `syncWallets` — and renders its backend portfolio; **account status** lists the linked cloud agent's wallets via `syncWallets`; **create account** (teller only) provisions a backend wallet, mapping the 409 "already provisioned" reply to a friendly notice. Disabled actions — the ATM's **withdraw** and **deposit** — render as muted chips with a "Soon" badge. Because an agent has exactly one account, **create account is dropped once the agent is known to have one** ([[src/renderer/src/screens/Office/RepInteractionPanel.tsx#rememberBank]]'s `hasAccount`). Signed-out, unlinked, and foreign states (the agent's cloud link belongs to a different Hermes account) render hints instead of errors. Results are guarded by a per-request token: switching the agent picker invalidates any in-flight action, so a late response can never render one agent's wallets under another.
 
 ### Session cache
diff --git a/lat.md/office-world-actions.md b/lat.md/office-world-actions.md
new file mode 100644
index 000000000..834caa7fd
--- /dev/null
+++ b/lat.md/office-world-actions.md
@@ -0,0 +1,62 @@
+# Office World Actions
+
+Chat-commanded errands in the Office 3D world: tell an agent "go to the bank and check my balance" and its avatar walks the trip route to the bank, stops at the teller or ATM, and the interaction modal opens with the requested action already running.
+
+The agent's own LLM does the understanding — the chat injects a vocabulary of world abilities, the model emits a machine-readable action block alongside its natural reply, and the renderer executes it. Adding a future ability (transfers, car purchase, other rooms) is one vocabulary entry plus a handler, not a new pipeline.
+
+The pipeline has four stages, deliberately decoupled: protocol ([[src/renderer/src/screens/Office/office3d/interactions/worldActions.ts]]) → orchestration ([[src/renderer/src/screens/Office/Office.tsx]]) → bus ([[src/renderer/src/screens/Office/office3d/interactions/missionBus.ts]]) → simulation ([[src/renderer/src/screens/Office/office3d/objects/AgentsLayer.tsx#AgentsLayer]]).
+
+## Action protocol
+
+The office chat prepends a request-side system message describing the abilities; when the user's request maps to one, the model appends a fenced ```world-action JSON block to its reply, which the renderer strips from the visible text and validates.
+
+[[src/renderer/src/screens/Office/office3d/interactions/worldActions.ts#buildWorldActionSystemPrompt]] generates the vocabulary from a declarative `ABILITIES` list (one entry per ability, so prompt and parser can't drift apart). Abilities today: `go_to` (bank, showroom) and `bank` operations (check_balance / account_status / create_account, via teller or ATM — create_account normalises to the teller, its only flow). [[src/renderer/src/screens/Office/office3d/interactions/worldActions.ts#parseWorldActions]] is tolerant by design: malformed JSON and unknown `do` values are stripped from the text but run nothing, so a newer prompt never breaks an older desktop. [[src/renderer/src/screens/Office/office3d/interactions/worldActions.ts#planWorldActions]] reduces a validated action list to one plan — a walking destination plus at most one facility interaction; bank operations force the bank as destination.
+
+The system message is injected into `sendMessage`'s history array (role "system") in [[src/renderer/src/screens/Office/OneChatModal.tsx]], so it is never persisted; transcripts stay clean and reloads only strip blocks (via `toChatMessages`) without re-running them — a reopened chat can never replay an old errand.
+
+## Mission bus
+
+A tiny module-level pub/sub bridging the DOM side (chat, modals, camera) and the r3f Canvas simulation, which mutates refs per-frame and can't share React context across the Canvas boundary.
+
+A `Mission` is one commanded errand: agent id, destination, and an optional interaction (rep id + panel action). [[src/renderer/src/screens/Office/office3d/interactions/missionBus.ts#dispatchMission]] hands it to the simulation, [[src/renderer/src/screens/Office/office3d/interactions/missionBus.ts#completeMission]] tells the sim the modal closed, and [[src/renderer/src/screens/Office/office3d/interactions/missionBus.ts#emitMissionEvent]] reports progress back ("arrived", "ended"). Plain Sets, no React, no allocations in the frame path — the low-end-device rule for all of Office 3D.
+
+## Commanded trips
+
+A mission reuses the existing trip machinery ([[office-3d-interiors#Office 3D Interiors#Agent trips]]) — same routes, collision, crowd separation — with a "visit" phase instead of random wandering.
+
+On dispatch, [[src/renderer/src/screens/Office/office3d/objects/AgentsLayer.tsx#AgentsLayer]] puts the agent's controller into trip mode on [[src/renderer/src/screens/Office/office3d/trips.ts#getTripRoute]], joining at [[src/renderer/src/screens/Office/office3d/trips.ts#nearestRouteIdx]] so a mission can start from a desk, the rest room, or mid-trip anywhere; an agent already inside the destination skips straight to the visit. Office-interior legs route through the partition/CEO doorways via [[src/renderer/src/screens/Office/office3d/core/routing.ts#routeTarget]]'s door gates (missions can start at any desk — random trips only ever started in the rest room, which is why single-hop routing used to suffice; see [[office-3d-interiors#Office 3D Interiors#Collision]]). Unlike random trips, a working agent is not turned around: being sent on an errand while working is the point.
+
+The visit phase walks to the interaction's named stop — `TripRoute.stops`, keyed by rep id, reusing proven collision-clear wander points (teller counter, ATM row) — emits "arrived", then stands holding until `completeMission` or a timeout (2 min with a modal pending, 15 s for a plain go_to), and finally walks the route home in reverse. A superseding mission for the same agent ends the previous one first.
+
+## Orchestration
+
+Office.tsx owns the mission lifecycle: it turns parsed actions into a mission, points the camera, and opens the interaction modal on arrival.
+
+`handleWorldActions` (in [[src/renderer/src/screens/Office/Office.tsx]]) plans the actions, dispatches the mission, closes the chat, and pulls back to the city view to watch the walk (walk mode keeps its own camera). On "arrived" it selects the agent, flies into the destination interior, and — when the mission has an interaction — opens [[src/renderer/src/screens/Office/RepInteractionPanel.tsx#RepInteractionPanel]] with an `autoAction`, which the panel runs exactly once after its account scope resolves (running earlier would race the cache-key change that bumps `requestSeq` and drops in-flight results). Whichever way the modal goes away (close, Escape, exiting the interior, walk-mode movement), an effect watching `activeRepId` completes the mission so the agent heads home. The reverse direction holds too: if the simulation times out the interaction hold and emits "ended" while the panel is still open, the panel is closed with it — UI and mission state always describe the same interaction.
+
+## Tests
+
+Vitest suites covering the protocol and the bus; the walking behaviour rides on the existing trip machinery covered by the interiors docs.
+
+- [[src/renderer/src/screens/Office/office3d/interactions/worldActions.test.ts]] — prompt/parse/plan
+- [[src/renderer/src/screens/Office/office3d/interactions/missionBus.test.ts]] — pub/sub contract
+
+### Prompt advertises every ability
+
+Every JSON example the vocabulary prompt shows must itself parse as a valid action — a vocabulary the parser rejects would teach the model dead syntax.
+
+### Parses and strips action blocks
+
+A reply carrying a world-action block yields the validated actions and clean display text; a bare object is accepted as a one-item array.
+
+### Tolerates malformed blocks
+
+Malformed JSON and unknown abilities are stripped from the visible text but produce no actions — bad model output degrades to a normal chat reply, never a crash or a wrong errand.
+
+### Bank operations force the bank
+
+Planning maps a bank operation to the bank destination and the right representative (teller vs ATM), overriding any conflicting go_to, and a plain go_to yields a walk with no interaction.
+
+### Bus delivers and unsubscribes
+
+Missions, completions, and events reach subscribers; unsubscribed listeners stop receiving so a torn-down AgentsLayer never acts on a mission with a stale controller map.
diff --git a/src/renderer/src/screens/Office/Office.tsx b/src/renderer/src/screens/Office/Office.tsx
index d5f7ee61c..c703119da 100644
--- a/src/renderer/src/screens/Office/Office.tsx
+++ b/src/renderer/src/screens/Office/Office.tsx
@@ -17,7 +17,21 @@ import OneChatModal from "./OneChatModal";
 import Office3D from "./office3d/Office3D";
 import RepInteractionPanel from "./RepInteractionPanel";
 import { officeAgentsChanged, profilesToOfficeAgents } from "./office3d/agents";
-import { getRepresentative } from "./office3d/interactions/registry";
+import {
+  getRepresentative,
+  type RepActionId,
+} from "./office3d/interactions/registry";
+import {
+  completeMission,
+  dispatchMission,
+  makeMissionId,
+  onMissionEvent,
+  type Mission,
+} from "./office3d/interactions/missionBus";
+import {
+  planWorldActions,
+  type WorldAction,
+} from "./office3d/interactions/worldActions";
 import type { ShowroomCar } from "./office3d/objects/CarShowroom";
 import type { BuildingId, OfficeLocation } from "./office3d/core/locations";
 import type { AgentPlace, OfficeAgent } from "./office3d/core/types";
@@ -68,6 +82,11 @@ function Office({ visible, profile }: OfficeProps): React.JSX.Element {
   const [carCard, setCarCard] = useState<ShowroomCar | null>(null);
   // Space-representative menu (bank tellers today): which rep's panel is open.
   const [activeRepId, setActiveRepId] = useState<string | null>(null);
+  // Chat-commanded world action in flight: the mission the agent is walking,
+  // and the rep-panel action to auto-run when its modal opens on arrival.
+  const missionRef = useRef<Mission | null>(null);
+  const missionRepOpenRef = useRef(false);
+  const [autoAction, setAutoAction] = useState<RepActionId | null>(null);
   // GTA-style walk mode: the user's avatar walks the city; interiors load by
   // walking through doorways and interactions fire with E near their points.
   const [walkMode, setWalkMode] = useState(false);
@@ -263,6 +282,72 @@ function Office({ visible, profile }: OfficeProps): React.JSX.Element {
   const closeRepPanel = useCallback(() => setActiveRepId(null), []);
   const activeRep = getRepresentative(activeRepId);
 
+  // Chat-driven world actions: the agent's reply asked for a physical errand.
+  // Compose a mission, hand it to the 3D simulation, and pull the camera back
+  // to the city so the user watches the walk (walk mode keeps its own camera).
+  const handleWorldActions = useCallback(
+    (agentId: string, actions: WorldAction[]) => {
+      const plan = planWorldActions(actions);
+      if (!plan || !agents.some((a) => a.id === agentId)) return;
+      const mission: Mission = {
+        id: makeMissionId(),
+        agentId,
+        dest: plan.dest,
+        interaction: plan.interaction,
+      };
+      missionRef.current = mission;
+      missionRepOpenRef.current = false;
+      setChatOpen(false);
+      setActiveRepId(null);
+      setAutoAction(null);
+      setCarCard(null);
+      if (!walkMode) {
+        setLocation("city");
+        setFocusedBuilding(null);
+      }
+      dispatchMission(mission);
+    },
+    [agents, walkMode],
+  );
+
+  // Mission progress from the simulation. Arrival flies the camera into the
+  // destination, selects the agent, and opens the rep panel with the
+  // commanded action; "ended" (walked home, superseded, timed out) clears it.
+  useEffect(() => {
+    return onMissionEvent((evt) => {
+      const pending = missionRef.current;
+      if (!pending || evt.mission.id !== pending.id) return;
+      if (evt.type === "arrived") {
+        setSelectedId(pending.agentId);
+        if (!walkMode) setLocation(pending.dest);
+        if (pending.interaction) {
+          missionRepOpenRef.current = true;
+          setAutoAction(pending.interaction.actionId);
+          setActiveRepId(pending.interaction.repId);
+        }
+      } else {
+        missionRef.current = null;
+        // The simulation gave up (interaction hold timed out) while the
+        // panel was still open: close it too, or the UI would keep serving
+        // an interaction whose agent has already walked home.
+        if (missionRepOpenRef.current) {
+          missionRepOpenRef.current = false;
+          setAutoAction(null);
+          setActiveRepId(null);
+        }
+      }
+    });
+  }, [walkMode]);
+
+  // However the mission's modal goes away (close button, Escape, exiting the
+  // interior, walk-mode moves), completing the mission sends the agent home.
+  useEffect(() => {
+    if (activeRepId !== null || !missionRepOpenRef.current) return;
+    missionRepOpenRef.current = false;
+    setAutoAction(null);
+    if (missionRef.current) completeMission(missionRef.current.id);
+  }, [activeRepId]);
+
   // Office desk → select its owner (opens the agent details sidebar).
   const handleDeskActivate = useCallback(
     (agentId: string) => setSelectedId(agentId),
@@ -772,6 +857,7 @@ function Office({ visible, profile }: OfficeProps): React.JSX.Element {
           open={chatOpen}
           onClose={() => setChatOpen(false)}
           agents={positionedAgents}
+          onWorldActions={handleWorldActions}
         />
 
         {activeRep && (
@@ -780,6 +866,7 @@ function Office({ visible, profile }: OfficeProps): React.JSX.Element {
             agents={positionedAgents}
             initialAgentId={selectedId ?? defaultAgentId}
             visible={visible ?? true}
+            autoAction={autoAction}
             onClose={closeRepPanel}
           />
         )}
diff --git a/src/renderer/src/screens/Office/OneChatModal.tsx b/src/renderer/src/screens/Office/OneChatModal.tsx
index eff066761..6d99ae169 100644
--- a/src/renderer/src/screens/Office/OneChatModal.tsx
+++ b/src/renderer/src/screens/Office/OneChatModal.tsx
@@ -1,11 +1,22 @@
 import { useState, useRef, useEffect } from "react";
 import { X, Send, Bot } from "lucide-react";
+import {
+  buildWorldActionSystemPrompt,
+  parseWorldActions,
+  stripWorldActionBlocks,
+  type WorldAction,
+} from "./office3d/interactions/worldActions";
 import type { OfficeAgent } from "./office3d/core/types";
 
 interface OneChatModalProps {
   open: boolean;
   onClose: () => void;
   agents: OfficeAgent[];
+  /**
+   * The agent's reply carried world actions ("go to the bank and check my
+   * balance"). The Office screen turns them into a mission.
+   */
+  onWorldActions?: (agentId: string, actions: WorldAction[]) => void;
 }
 
 interface ChatMessage {
@@ -15,10 +26,29 @@ interface ChatMessage {
   timestamp: number;
 }
 
+// Session rows → display messages. Assistant texts are stripped of
+// world-action blocks: the protocol JSON is machine traffic, never shown.
+function toChatMessages(
+  items: Array<{ kind: "user" | "assistant"; id: number; content?: string }>,
+): ChatMessage[] {
+  return items
+    .filter((it) => it.kind === "user" || it.kind === "assistant")
+    .map((it) => ({
+      id: `db-${it.id}`,
+      role: it.kind === "user" ? ("user" as const) : ("agent" as const),
+      text:
+        it.kind === "assistant"
+          ? stripWorldActionBlocks(it.content || "")
+          : it.content || "",
+      timestamp: Date.now(),
+    }));
+}
+
 export default function OneChatModal({
   open,
   onClose,
   agents,
+  onWorldActions,
 }: OneChatModalProps): React.JSX.Element | null {
   const [selectedAgentId, setSelectedAgentId] = useState<string | null>(null);
   const [input, setInput] = useState("");
@@ -61,15 +91,10 @@ export default function OneChatModal({
           content?: string;
         }>;
         if (cancelled) return;
-        const loaded: ChatMessage[] = items
-          .filter((it) => it.kind === "user" || it.kind === "assistant")
-          .map((it) => ({
-            id: `db-${it.id}`,
-            role: it.kind === "user" ? "user" : "agent",
-            text: it.content || "",
-            timestamp: Date.now(),
-          }));
-        setMessages((prev) => ({ ...prev, [selectedAgentId]: loaded }));
+        setMessages((prev) => ({
+          ...prev,
+          [selectedAgentId]: toChatMessages(items),
+        }));
       } catch {
         // Session may not exist yet — that's fine
       }
@@ -129,15 +154,29 @@ export default function OneChatModal({
     setLoadingMap((prev) => ({ ...prev, [selectedAgentId]: true }));
     try {
       const sessionId = `office-${selectedAgentId}`;
-      const history = (messages[selectedAgentId] ?? [])
-        .filter((m) => m.role === "user" || m.role === "agent")
-        .map((m) => ({ role: m.role, content: m.text }));
-      await window.hermesAPI.sendMessage(
+      // The world-action vocabulary rides along as a request-side system
+      // message: it's never persisted, so transcripts and reloads stay clean.
+      const history = [
+        {
+          role: "system",
+          content: buildWorldActionSystemPrompt(target.name),
+        },
+        ...(messages[selectedAgentId] ?? [])
+          .filter((m) => m.role === "user" || m.role === "agent")
+          .map((m) => ({ role: m.role, content: m.text })),
+      ];
+      const result = await window.hermesAPI.sendMessage(
         text,
         selectedAgentId,
         sessionId,
         history,
       );
+      // World actions ship only in the fresh reply (reloads merely strip
+      // them), so a reopened transcript can never replay an old errand.
+      const { actions } = parseWorldActions(result?.response ?? "");
+      if (actions.length > 0) {
+        onWorldActions?.(selectedAgentId, actions);
+      }
       // Reload persisted messages from the session
       const items = (await window.hermesAPI.getSessionMessages(
         sessionId,
@@ -146,15 +185,10 @@ export default function OneChatModal({
         id: number;
         content?: string;
       }>;
-      const loaded: ChatMessage[] = items
-        .filter((it) => it.kind === "user" || it.kind === "assistant")
-        .map((it) => ({
-          id: `db-${it.id}`,
-          role: it.kind === "user" ? "user" : "agent",
-          text: it.content || "",
-          timestamp: Date.now(),
-        }));
-      setMessages((prev) => ({ ...prev, [selectedAgentId]: loaded }));
+      setMessages((prev) => ({
+        ...prev,
+        [selectedAgentId]: toChatMessages(items),
+      }));
     } catch (err) {
       // The response may have been persisted even though the promise rejected.
       // Try to reload from the database before showing a raw error.
@@ -167,14 +201,7 @@ export default function OneChatModal({
           id: number;
           content?: string;
         }>;
-        const loaded: ChatMessage[] = items
-          .filter((it) => it.kind === "user" || it.kind === "assistant")
-          .map((it) => ({
-            id: `db-${it.id}`,
-            role: it.kind === "user" ? "user" : "agent",
-            text: it.content || "",
-            timestamp: Date.now(),
-          }));
+        const loaded = toChatMessages(items);
         if (loaded.length > 0) {
           setMessages((prev) => ({
             ...prev,
diff --git a/src/renderer/src/screens/Office/RepInteractionPanel.tsx b/src/renderer/src/screens/Office/RepInteractionPanel.tsx
index 4f7fd9b8c..c43ae123e 100644
--- a/src/renderer/src/screens/Office/RepInteractionPanel.tsx
+++ b/src/renderer/src/screens/Office/RepInteractionPanel.tsx
@@ -150,6 +150,7 @@ export default function RepInteractionPanel({
   agents,
   initialAgentId,
   visible = true,
+  autoAction = null,
   onClose,
 }: {
   rep: SpaceRepresentative;
@@ -159,6 +160,9 @@ export default function RepInteractionPanel({
   // stays mounted while the tab is hidden, so this re-triggers account
   // resolution when the user returns (see the account-scope effect below).
   visible?: boolean;
+  // Mission-driven open (chat world actions): run this action automatically
+  // once the panel is ready, as if the user had clicked its chip.
+  autoAction?: RepActionId | null;
   onClose: () => void;
 }): React.JSX.Element {
   const { t } = useI18n();
@@ -180,22 +184,33 @@ export default function RepInteractionPanel({
   // updates, the cache key changes, and the rehydrate effect misses the previous
   // account's entry instead of surfacing its portfolio.
   const [accountId, setAccountId] = useState<string | null>(null);
+  // Whether the getAccount round-trip has settled (either way). Auto-run
+  // waits for this: firing earlier would race the accountId resolution,
+  // whose cacheKey change bumps requestSeq and drops the in-flight result.
+  const [accountResolved, setAccountResolved] = useState(false);
   useEffect(() => {
     if (!visible) {
       // Hidden: forget the resolved account so a stale balance can never flash
       // on return before we re-check who's signed in. The rehydrate effect
       // falls back to idle while the account is unknown.
       setAccountId(null);
+      setAccountResolved(false);
       return;
     }
     let alive = true;
     void window.hermesAPI
       .getAccount()
       .then((acc) => {
-        if (alive) setAccountId(acc?.user.id ?? null);
+        if (alive) {
+          setAccountId(acc?.user.id ?? null);
+          setAccountResolved(true);
+        }
       })
       .catch(() => {
-        if (alive) setAccountId(null);
+        if (alive) {
+          setAccountId(null);
+          setAccountResolved(true);
+        }
       });
     return () => {
       alive = false;
@@ -423,6 +438,24 @@ export default function RepInteractionPanel({
     [agentId, cacheKey, hintForStatus, t],
   );
 
+  // Mission-driven open: run the commanded action exactly once, and only
+  // after the account scope has settled (see accountResolved above). Declared
+  // after the rehydrate effect so on the triggering commit the cache
+  // rehydrate runs first and this action's request is the newest.
+  const autoRanRef = useRef(false);
+  useEffect(() => {
+    autoRanRef.current = false;
+  }, [autoAction]);
+  useEffect(() => {
+    if (!autoAction || autoRanRef.current || !accountResolved || !agentId) {
+      return;
+    }
+    const action = rep.actions.find((a) => a.id === autoAction && !a.disabled);
+    if (!action) return;
+    autoRanRef.current = true;
+    void runAction(autoAction);
+  }, [autoAction, accountResolved, agentId, rep, runAction]);
+
   const selectedAgent = agents.find((a) => a.id === agentId) ?? null;
   const busy = state.kind === "loading";
 
diff --git a/src/renderer/src/screens/Office/office3d/core/routing.test.ts b/src/renderer/src/screens/Office/office3d/core/routing.test.ts
new file mode 100644
index 000000000..9d0b039dd
--- /dev/null
+++ b/src/renderer/src/screens/Office/office3d/core/routing.test.ts
@@ -0,0 +1,98 @@
+// @vitest-environment node
+import { describe, expect, it } from "vitest";
+import { routeTarget } from "./routing";
+import { GLASS_WALLS, INTERIOR_WALLS, REST_SEATS } from "../layout";
+
+interface Rect {
+  x: number;
+  y: number;
+  w: number;
+  h: number;
+}
+
+// Liang–Barsky segment vs axis-aligned rect intersection.
+function segmentHitsRect(
+  x1: number,
+  y1: number,
+  x2: number,
+  y2: number,
+  r: Rect,
+): boolean {
+  const dx = x2 - x1;
+  const dy = y2 - y1;
+  let t0 = 0;
+  let t1 = 1;
+  const clips: Array<[number, number]> = [
+    [-dx, x1 - r.x],
+    [dx, r.x + r.w - x1],
+    [-dy, y1 - r.y],
+    [dy, r.y + r.h - y1],
+  ];
+  for (const [p, q] of clips) {
+    if (p === 0) {
+      if (q < 0) return false;
+      continue;
+    }
+    const t = q / p;
+    if (p < 0) {
+      if (t > t1) return false;
+      if (t > t0) t0 = t;
+    } else {
+      if (t < t0) return false;
+      if (t < t1) t1 = t;
+    }
+  }
+  return true;
+}
+
+const WALLS: Rect[] = [...INTERIOR_WALLS, ...GLASS_WALLS];
+
+/**
+ * Follow routeTarget hop by hop (as the frame loop does: recompute after
+ * every arrival) and assert no straight hop crosses an interior wall — a
+ * crossing means the walker would pin against the wall face and, in a
+ * concave pocket, deadlock (the CEO-office stuck-agent bug).
+ */
+function walkAsserted(start: [number, number], target: [number, number]): void {
+  let [x, y] = start;
+  for (let hop = 0; hop < 12; hop++) {
+    const wp = routeTarget(x, y, target[0], target[1]);
+    for (const wall of WALLS) {
+      expect(
+        segmentHitsRect(x, y, wp.x, wp.y, wall),
+        `hop (${x},${y})→(${wp.x},${wp.y}) crosses wall at (${wall.x},${wall.y})`,
+      ).toBe(false);
+    }
+    [x, y] = [wp.x, wp.y];
+    if (wp.x === target[0] && wp.y === target[1]) return;
+  }
+  throw new Error("route did not converge in 12 hops");
+}
+
+const CEO_SEAT: [number, number] = [300, 1360];
+const OFFICE_DOOR: [number, number] = [1233, 1756];
+
+describe("office door-gate routing", () => {
+  it("leaving the CEO office routes through the glass door, never the wall", () => {
+    // The original bug: divider crossing was checked first, so a CEO→east
+    // walk aimed at the partition door and pinned against the north glass.
+    walkAsserted(CEO_SEAT, [REST_SEATS[0].x, REST_SEATS[0].y]);
+  });
+
+  it("southern starts reach the exterior door without clipping the partition", () => {
+    // From south of the door band, a straight line at the far-side gate
+    // crosses partition-bottom below the gap — the near gate hop prevents it.
+    walkAsserted([900, 1650], OFFICE_DOOR);
+    walkAsserted(CEO_SEAT, OFFICE_DOOR);
+  });
+
+  it("desk-to-rest and rest-to-CEO walks stay wall-clean", () => {
+    walkAsserted([355, 540], [1560, 820]);
+    walkAsserted([REST_SEATS[0].x, REST_SEATS[0].y], CEO_SEAT);
+  });
+
+  it("same-room walks go straight at the target", () => {
+    expect(routeTarget(200, 300, 800, 600)).toEqual({ x: 800, y: 600 });
+    expect(routeTarget(1300, 400, 1560, 820)).toEqual({ x: 1560, y: 820 });
+  });
+});
diff --git a/src/renderer/src/screens/Office/office3d/core/routing.ts b/src/renderer/src/screens/Office/office3d/core/routing.ts
new file mode 100644
index 000000000..0ceec9cfe
--- /dev/null
+++ b/src/renderer/src/screens/Office/office3d/core/routing.ts
@@ -0,0 +1,78 @@
+/**
+ * Waypoint routing inside the office building. There is no full pathfinder:
+ * walkers steer straight at a target and rely on wall-follow to skim past
+ * convex obstacles. That makes doorways the one thing that must be routed
+ * explicitly — a straight line at a target beyond a wall pins the walker
+ * against it, and in a concave pocket (a wall corner plus furniture) the
+ * wall-follow re-derives opposite slides every frame and deadlocks in place.
+ *
+ * Every room crossing is therefore a two-hop "door gate": first walk to the
+ * gate point on the NEAR side of the doorway, then to the far-side gate. The
+ * near gate is reachable in a straight line from anywhere in its room, and
+ * the near→far hop crosses the wall inside the door gap by construction —
+ * so routing is position-independent. (The old single-hop version aimed
+ * straight at the far gate; from a CEO seat or anywhere south of the door
+ * band the line crossed the wall outside the gap and stranded the agent —
+ * unnoticed while walks only ever started from desks and rest seats, exposed
+ * by chat-commanded missions that can start anywhere.)
+ */
+import { CEO_OFFICE, CEO_DOOR_Y, DIVIDER_X, DOOR_Y } from "../layout";
+
+/** How far a gate point sits from its wall, on each side of the doorway. */
+const GATE_OFFSET = 60;
+/**
+ * "At the gate" tolerance: within this box around the near gate the walker
+ * is inside the door band, so the straight hop to the far gate passes
+ * through the gap. The y band stays inside the narrower of the two door
+ * gaps (±90); x allows the walker to have been pushed around a little.
+ */
+const GATE_BAND_Y = 80;
+const GATE_BAND_X = 140;
+
+function throughGate(
+  ax: number,
+  ay: number,
+  wallX: number,
+  doorY: number,
+  crossingEast: boolean,
+): { x: number; y: number } {
+  const atGate =
+    Math.abs(ay - doorY) <= GATE_BAND_Y && Math.abs(ax - wallX) <= GATE_BAND_X;
+  const side = atGate === crossingEast ? 1 : -1;
+  return { x: wallX + side * GATE_OFFSET, y: doorY };
+}
+
+function inCeoBox(x: number, y: number): boolean {
+  return x < CEO_OFFICE.maxX && y > CEO_OFFICE.minY;
+}
+
+/**
+ * Next waypoint on the way to (finalX, finalY), recomputed every frame.
+ * Returns the final target unchanged when no room boundary is in the way.
+ */
+export function routeTarget(
+  ax: number,
+  ay: number,
+  finalX: number,
+  finalY: number,
+): { x: number; y: number } {
+  // Leaving the CEO glass office always goes through its own doorway first —
+  // checked before the divider, or a CEO→east walk aims at the divider door
+  // and pins against the glass (the original stuck-in-the-corner bug).
+  const inCeo = inCeoBox(ax, ay);
+  const targetInCeo = inCeoBox(finalX, finalY);
+  if (inCeo && !targetInCeo) {
+    return throughGate(ax, ay, CEO_OFFICE.maxX, CEO_DOOR_Y, true);
+  }
+
+  const onEast = ax > DIVIDER_X;
+  const targetEast = finalX > DIVIDER_X;
+  if (onEast !== targetEast) {
+    return throughGate(ax, ay, DIVIDER_X, DOOR_Y, targetEast);
+  }
+
+  if (!inCeo && targetInCeo) {
+    return throughGate(ax, ay, CEO_OFFICE.maxX, CEO_DOOR_Y, false);
+  }
+  return { x: finalX, y: finalY };
+}
diff --git a/src/renderer/src/screens/Office/office3d/interactions/missionBus.test.ts b/src/renderer/src/screens/Office/office3d/interactions/missionBus.test.ts
new file mode 100644
index 000000000..7494492ba
--- /dev/null
+++ b/src/renderer/src/screens/Office/office3d/interactions/missionBus.test.ts
@@ -0,0 +1,60 @@
+// @vitest-environment node
+import { describe, expect, it } from "vitest";
+import {
+  completeMission,
+  dispatchMission,
+  emitMissionEvent,
+  makeMissionId,
+  onMission,
+  onMissionComplete,
+  onMissionEvent,
+  type Mission,
+} from "./missionBus";
+
+function mission(): Mission {
+  return {
+    id: makeMissionId(),
+    agentId: "agent-1",
+    dest: "bank",
+    interaction: { repId: "atm", actionId: "checkBalance" },
+  };
+}
+
+describe("mission bus", () => {
+  // @lat: [[office-world-actions#Tests#Bus delivers and unsubscribes]]
+  it("delivers missions, completions, and events to subscribers", () => {
+    const seen: Mission[] = [];
+    const completed: string[] = [];
+    const events: string[] = [];
+    const offMission = onMission((m) => seen.push(m));
+    const offComplete = onMissionComplete((id) => completed.push(id));
+    const offEvent = onMissionEvent((e) => events.push(e.type));
+
+    const m = mission();
+    dispatchMission(m);
+    completeMission(m.id);
+    emitMissionEvent({ type: "arrived", mission: m });
+    emitMissionEvent({ type: "ended", mission: m });
+
+    expect(seen).toEqual([m]);
+    expect(completed).toEqual([m.id]);
+    expect(events).toEqual(["arrived", "ended"]);
+
+    // Unsubscribed listeners stop receiving — a torn-down AgentsLayer must
+    // never act on a mission for a stale controller map.
+    offMission();
+    offComplete();
+    offEvent();
+    dispatchMission(mission());
+    completeMission("nope");
+    emitMissionEvent({ type: "ended", mission: m });
+    expect(seen).toHaveLength(1);
+    expect(completed).toHaveLength(1);
+    expect(events).toHaveLength(2);
+  });
+
+  it("mints unique mission ids", () => {
+    const ids = new Set([makeMissionId(), makeMissionId(), makeMissionId()]);
+    expect(ids.size).toBe(3);
+  });
+});
diff --git a/src/renderer/src/screens/Office/office3d/interactions/missionBus.ts b/src/renderer/src/screens/Office/office3d/interactions/missionBus.ts
new file mode 100644
index 000000000..9e2ab0922
--- /dev/null
+++ b/src/renderer/src/screens/Office/office3d/interactions/missionBus.ts
@@ -0,0 +1,76 @@
+/**
+ * Mission bus: the imperative bridge between the DOM side of the Office tab
+ * (chat, modals, camera in Office.tsx) and the 3D simulation (AgentsLayer's
+ * per-frame controller inside the r3f Canvas). React context doesn't cross
+ * the Canvas boundary and the sim mutates refs without re-rendering, so this
+ * is a tiny module-level pub/sub — plain Sets, no React, no allocations in
+ * the frame path.
+ *
+ * A mission is one commanded errand: an agent walks the existing trip route
+ * to a destination, optionally stops at a facility (teller counter, ATM),
+ * reports arrival, holds while the interaction modal is open, and walks home
+ * when the mission is completed (or times out).
+ */
+import type { RepActionId } from "./registry";
+import type { WorldPlace } from "./worldActions";
+
+export interface MissionInteraction {
+  /** Space representative to stop at and open (registry id). */
+  repId: string;
+  /** Rep-panel action to auto-run when the modal opens. */
+  actionId: RepActionId;
+}
+
+export interface Mission {
+  id: string;
+  agentId: string;
+  dest: WorldPlace;
+  interaction: MissionInteraction | null;
+}
+
+export type MissionEvent =
+  | { type: "arrived"; mission: Mission }
+  | { type: "ended"; mission: Mission };
+
+type Listener<T> = (value: T) => void;
+
+const missionListeners = new Set<Listener<Mission>>();
+const completeListeners = new Set<Listener<string>>();
+const eventListeners = new Set<Listener<MissionEvent>>();
+
+let missionSeq = 0;
+
+export function makeMissionId(): string {
+  missionSeq += 1;
+  return `mission-${missionSeq}`;
+}
+
+/** Command an agent onto a mission (consumed by AgentsLayer). */
+export function dispatchMission(mission: Mission): void {
+  for (const cb of missionListeners) cb(mission);
+}
+
+export function onMission(cb: Listener<Mission>): () => void {
+  missionListeners.add(cb);
+  return () => missionListeners.delete(cb);
+}
+
+/** The interaction finished (modal closed) — the agent may head home. */
+export function completeMission(missionId: string): void {
+  for (const cb of completeListeners) cb(missionId);
+}
+
+export function onMissionComplete(cb: Listener<string>): () => void {
+  completeListeners.add(cb);
+  return () => completeListeners.delete(cb);
+}
+
+/** Sim → UI progress (arrival at the destination, mission over). */
+export function emitMissionEvent(event: MissionEvent): void {
+  for (const cb of eventListeners) cb(event);
+}
+
+export function onMissionEvent(cb: Listener<MissionEvent>): () => void {
+  eventListeners.add(cb);
+  return () => eventListeners.delete(cb);
+}
diff --git a/src/renderer/src/screens/Office/office3d/interactions/worldActions.test.ts b/src/renderer/src/screens/Office/office3d/interactions/worldActions.test.ts
new file mode 100644
index 000000000..7e7bc38bf
--- /dev/null
+++ b/src/renderer/src/screens/Office/office3d/interactions/worldActions.test.ts
@@ -0,0 +1,109 @@
+// @vitest-environment node
+import { describe, expect, it } from "vitest";
+import {
+  buildWorldActionSystemPrompt,
+  parseWorldActions,
+  planWorldActions,
+  stripWorldActionBlocks,
+} from "./worldActions";
+
+describe("world-action prompt", () => {
+  // @lat: [[office-world-actions#Tests#Prompt advertises every ability]]
+  it("advertises every ability with valid JSON examples", () => {
+    const prompt = buildWorldActionSystemPrompt("fatha");
+    expect(prompt).toContain("fatha");
+    expect(prompt).toContain('"go_to"');
+    expect(prompt).toContain('"bank"');
+    expect(prompt).toContain("world-action");
+    // Every advertised example must itself parse as a valid action — a
+    // vocabulary the parser rejects would teach the model dead syntax.
+    const examples = prompt.match(/\{"do":[^\n]*\}/g) ?? [];
+    expect(examples.length).toBeGreaterThan(0);
+    for (const example of examples) {
+      const { actions } = parseWorldActions(
+        "ok\n```world-action\n" + example + "\n```",
+      );
+      expect(actions).toHaveLength(1);
+    }
+  });
+});
+
+describe("world-action parsing", () => {
+  // @lat: [[office-world-actions#Tests#Parses and strips action blocks]]
+  it("extracts a valid block and strips it from the visible text", () => {
+    const reply =
+      'On my way to the bank.\n```world-action\n[{"do":"bank","operation":"check_balance","via":"atm"}]\n```';
+    const { text, actions } = parseWorldActions(reply);
+    expect(text).toBe("On my way to the bank.");
+    expect(actions).toEqual([
+      { do: "bank", operation: "checkBalance", via: "atm" },
+    ]);
+  });
+
+  it("parses CRLF-formatted blocks (never leaks protocol JSON into chat)", () => {
+    const reply =
+      'Heading out.\r\n```world-action\r\n[{"do":"go_to","place":"bank"}]\r\n```';
+    const { text, actions } = parseWorldActions(reply);
+    expect(text).toBe("Heading out.");
+    expect(actions).toEqual([{ do: "go_to", place: "bank" }]);
+    expect(stripWorldActionBlocks(reply)).toBe("Heading out.");
+  });
+
+  it("accepts a bare object as a one-item array", () => {
+    const { actions } = parseWorldActions(
+      '```world-action\n{"do":"go_to","place":"showroom"}\n```',
+    );
+    expect(actions).toEqual([{ do: "go_to", place: "showroom" }]);
+  });
+
+  // @lat: [[office-world-actions#Tests#Tolerates malformed blocks]]
+  it("strips malformed or unknown blocks without running anything", () => {
+    const malformed = "Sure.\n```world-action\nnot json at all\n```";
+    expect(parseWorldActions(malformed)).toEqual({
+      text: "Sure.",
+      actions: [],
+    });
+    const unknown =
+      'Done.\n```world-action\n[{"do":"teleport","place":"moon"},{"do":"go_to","place":"mars"}]\n```';
+    expect(parseWorldActions(unknown)).toEqual({ text: "Done.", actions: [] });
+  });
+
+  it("normalises create_account away from the ATM (teller-only flow)", () => {
+    const { actions } = parseWorldActions(
+      '```world-action\n{"do":"bank","operation":"create_account","via":"atm"}\n```',
+    );
+    expect(actions).toEqual([
+      { do: "bank", operation: "createAccount", via: "teller" },
+    ]);
+  });
+
+  it("plain replies pass through untouched", () => {
+    expect(parseWorldActions("Just chatting, no errands.")).toEqual({
+      text: "Just chatting, no errands.",
+      actions: [],
+    });
+    expect(stripWorldActionBlocks("hello")).toBe("hello");
+  });
+});
+
+describe("world-action planning", () => {
+  // @lat: [[office-world-actions#Tests#Bank operations force the bank]]
+  it("a bank operation forces the bank and picks the right rep", () => {
+    const plan = planWorldActions([
+      { do: "go_to", place: "showroom" },
+      { do: "bank", operation: "checkBalance", via: "atm" },
+    ]);
+    expect(plan).toEqual({
+      dest: "bank",
+      interaction: { repId: "atm", actionId: "checkBalance" },
+    });
+  });
+
+  it("a plain go_to yields a walk with no interaction", () => {
+    expect(planWorldActions([{ do: "go_to", place: "showroom" }])).toEqual({
+      dest: "showroom",
+      interaction: null,
+    });
+    expect(planWorldActions([])).toBeNull();
+  });
+});
diff --git a/src/renderer/src/screens/Office/office3d/interactions/worldActions.ts b/src/renderer/src/screens/Office/office3d/interactions/worldActions.ts
new file mode 100644
index 000000000..932281ab6
--- /dev/null
+++ b/src/renderer/src/screens/Office/office3d/interactions/worldActions.ts
@@ -0,0 +1,173 @@
+/**
+ * World actions: the protocol that lets an agent's LLM drive its own 3D
+ * avatar from the office chat. The chat injects a vocabulary of abilities as
+ * a system message; when the user asks for something physical ("go to the
+ * bank and check my balance") the model appends a fenced ```world-action
+ * JSON block to its reply. The renderer strips the block from the visible
+ * text, validates it here, and turns it into a mission (see missionBus.ts).
+ *
+ * Extensibility contract: every ability is one ABILITIES entry (the prompt is
+ * generated from it) plus a case in parseAction/planWorldActions. Unknown
+ * `do` values parse to nothing — an older desktop ignores abilities a newer
+ * prompt advertises rather than breaking.
+ */
+import type { RepActionId } from "./registry";
+
+/** Places an agent can be sent to. Matches trip destinations in trips.ts. */
+export type WorldPlace = "bank" | "showroom";
+
+const WORLD_PLACES: readonly WorldPlace[] = ["bank", "showroom"];
+
+/** Bank operations the model may request, mapped to rep-panel actions. */
+const BANK_OPERATIONS: Record<string, RepActionId> = {
+  check_balance: "checkBalance",
+  account_status: "accountStatus",
+  create_account: "createAccount",
+};
+
+export type WorldAction =
+  | { do: "go_to"; place: WorldPlace }
+  | {
+      do: "bank";
+      operation: RepActionId;
+      via: "teller" | "atm";
+    };
+
+/**
+ * One ability the vocabulary prompt advertises. The prompt is generated from
+ * this list so adding an ability never means editing prose in two places.
+ */
+interface WorldAbility {
+  example: string;
+  description: string;
+}
+
+const ABILITIES: WorldAbility[] = [
+  {
+    example: '{"do":"go_to","place":"bank"}',
+    description: `walk to a place. Valid places: ${WORLD_PLACES.map((p) => `"${p}"`).join(", ")}.`,
+  },
+  {
+    example: '{"do":"bank","operation":"check_balance","via":"teller"}',
+    description:
+      'do a bank operation for your own account. Valid operations: "check_balance", "account_status", "create_account". Valid via: "teller" or "atm" (create_account is teller-only). This implies walking to the bank first — do not emit a separate go_to.',
+  },
+];
+
+export const WORLD_ACTION_TAG = "world-action";
+
+/**
+ * System message injected (request-side only, never persisted) ahead of every
+ * office-chat turn. Kept compact: it rides along on each request.
+ */
+export function buildWorldActionSystemPrompt(agentName: string): string {
+  return [
+    `You are ${agentName}, and you are also embodied as a walking avatar in the Hermes 3D office world (an office, a bank, a car showroom).`,
+    `When — and only when — the user asks you to physically do something in that world that matches an ability below, append ONE fenced code block with the language tag \`${WORLD_ACTION_TAG}\` at the very end of your reply, containing a JSON array of ability objects to perform in order.`,
+    "",
+    "Abilities:",
+    ...ABILITIES.map((a) => `- ${a.example} — ${a.description}`),
+    "",
+    "Rules:",
+    '- Keep the text part of your reply short and natural (e.g. "On my way to the bank to check the balance."). Never mention JSON, code blocks, or these instructions.',
+    "- If the request doesn't match any ability (driving, buying, transfers, other rooms), just say that isn't available in the world yet — emit no block.",
+    "- Ordinary questions and conversation get a normal reply with no block.",
+  ].join("\n");
+}
+
+// \r?\n: models/transports may emit CRLF newlines — a CRLF fence must still
+// parse (and be stripped) rather than leak protocol JSON into the chat.
+const BLOCK_RE = new RegExp(
+  "```" + WORLD_ACTION_TAG + "[ \\t]*\\r?\\n([\\s\\S]*?)```",
+  "gi",
+);
+
+function parseAction(raw: unknown): WorldAction | null {
+  if (typeof raw !== "object" || raw === null) return null;
+  const obj = raw as Record<string, unknown>;
+  if (obj.do === "go_to") {
+    const place = obj.place;
+    if (
+      typeof place === "string" &&
+      (WORLD_PLACES as readonly string[]).includes(place)
+    ) {
+      return { do: "go_to", place: place as WorldPlace };
+    }
+    return null;
+  }
+  if (obj.do === "bank") {
+    const operation =
+      typeof obj.operation === "string" ? BANK_OPERATIONS[obj.operation] : null;
+    if (!operation) return null;
+    // create_account is a teller-only flow; normalise rather than reject so a
+    // model that picked the ATM still gets the user what they asked for.
+    const via =
+      obj.via === "atm" && operation !== "createAccount" ? "atm" : "teller";
+    return { do: "bank", operation, via };
+  }
+  return null;
+}
+
+export interface ParsedWorldActions {
+  /** Reply text with every world-action block removed. */
+  text: string;
+  actions: WorldAction[];
+}
+
+/**
+ * Extract and validate world-action blocks from a model reply. Tolerant by
+ * design: malformed JSON or unknown abilities are dropped silently (the
+ * visible text still reads fine), and a bare object is accepted as a
+ * one-item array.
+ */
+export function parseWorldActions(reply: string): ParsedWorldActions {
+  const actions: WorldAction[] = [];
+  const text = reply
+    .replace(BLOCK_RE, (_match, body: string) => {
+      try {
+        const parsed: unknown = JSON.parse(body.trim());
+        const list = Array.isArray(parsed) ? parsed : [parsed];
+        for (const item of list) {
+          const action = parseAction(item);
+          if (action) actions.push(action);
+        }
+      } catch {
+        // Malformed block: strip it from the text but run nothing.
+      }
+      return "";
+    })
+    .trim();
+  return { text, actions };
+}
+
+/** Display-side helper: remove world-action blocks without running them. */
+export function stripWorldActionBlocks(text: string): string {
+  return text.replace(BLOCK_RE, "").trim();
+}
+
+/**
+ * What a validated action list means for the world: one walking destination
+ * and at most one facility interaction on arrival. Bank operations force the
+ * bank as destination; a trailing plain go_to elsewhere loses to it.
+ */
+export interface WorldPlan {
+  dest: WorldPlace;
+  interaction: { repId: string; actionId: RepActionId } | null;
+}
+
+export function planWorldActions(actions: WorldAction[]): WorldPlan | null {
+  let dest: WorldPlace | null = null;
+  let interaction: WorldPlan["interaction"] = null;
+  for (const action of actions) {
+    if (action.do === "go_to") {
+      if (!interaction) dest = action.place;
+    } else if (action.do === "bank") {
+      dest = "bank";
+      interaction = {
+        repId: action.via === "atm" ? "atm" : "bank-teller",
+        actionId: action.operation,
+      };
+    }
+  }
+  return dest ? { dest, interaction } : null;
+}
diff --git a/src/renderer/src/screens/Office/office3d/objects/AgentsLayer.tsx b/src/renderer/src/screens/Office/office3d/objects/AgentsLayer.tsx
index eacbd5a4b..e2259a098 100644
--- a/src/renderer/src/screens/Office/office3d/objects/AgentsLayer.tsx
+++ b/src/renderer/src/screens/Office/office3d/objects/AgentsLayer.tsx
@@ -3,17 +3,10 @@ import { useFrame } from "@react-three/fiber";
 import type * as THREE from "three";
 import { AgentModel } from "./agents";
 import { RIGGED_EMPLOYEE_URL, RIGGED_MAN_URL } from "./RiggedCharacter";
-import {
-  REST_SEATS,
-  CEO_OFFICE,
-  CEO_DOOR_Y,
-  DIVIDER_X,
-  DOOR_Y,
-  type Workstation,
-  type Seat,
-} from "../layout";
+import { REST_SEATS, type Workstation, type Seat } from "../layout";
 import { WALK_SPEED } from "../core/constants";
 import { toWorld, worldToCanvas } from "../core/geometry";
+import { routeTarget } from "../core/routing";
 import {
   applyCrowdSeparation,
   buildOfficeColliders,
@@ -29,9 +22,17 @@ import {
   TRIP_DWELL_MS,
   TRIP_WALK_SPEED,
   pickTripRoute,
+  getTripRoute,
+  nearestRouteIdx,
   classifyTripPlace,
   type TripRoute,
 } from "../trips";
+import {
+  emitMissionEvent,
+  onMission,
+  onMissionComplete,
+  type Mission,
+} from "../interactions/missionBus";
 import type { AgentPlace, OfficeAgent, RenderAgent } from "../core/types";
 
 // Walking speed (canvas units / second) and arrival threshold.
@@ -43,9 +44,15 @@ const TRIP_ARRIVE_DISTANCE = 25;
 
 type ControllerMode = "toSeat" | "seated" | "trip";
 
+// How long a mission agent holds at its interaction stop before giving up
+// and walking home: generous while a modal may be open, short for a plain
+// "go there" errand.
+const MISSION_HOLD_MS = 120_000;
+const MISSION_LINGER_MS = 15_000;
+
 interface TripState {
   route: TripRoute;
-  phase: "out" | "wander" | "back";
+  phase: "out" | "wander" | "visit" | "back";
   /** Index into route.points ("out" walks up, "back" walks down). */
   idx: number;
   wanderIdx: number;
@@ -53,6 +60,14 @@ interface TripState {
   dwellUntil: number;
   /** When to head home (set when the wander phase starts). */
   endAt: number;
+  /** Commanded mission driving this trip (random trips leave it unset). */
+  mission?: Mission;
+  /** Mission visit: reached the interaction stop and told the UI. */
+  arrived?: boolean;
+  /** Walk home no later than this, even if the modal never closes. */
+  holdUntil?: number;
+  /** Set via the mission bus when the interaction modal closes. */
+  done?: boolean;
 }
 
 interface ControllerState {
@@ -73,33 +88,6 @@ function randomBetween(min: number, max: number): number {
   return min + Math.random() * (max - min);
 }
 
-// Doorway waypoints just inside each room, so agents pass through the gap in
-// the partition instead of clipping the wall (we have no full pathfinder).
-function routeTarget(
-  ax: number,
-  ay: number,
-  finalX: number,
-  finalY: number,
-): { x: number; y: number } {
-  const onEast = ax > DIVIDER_X;
-  const targetEast = finalX > DIVIDER_X;
-  if (onEast !== targetEast) {
-    return { x: targetEast ? DIVIDER_X + 60 : DIVIDER_X - 60, y: DOOR_Y };
-  }
-  // CEO glass corner office: route through the doorway gap in its east glass
-  // wall when crossing the boundary in either direction.
-  const inCeoOffice = ax < CEO_OFFICE.maxX && ay > CEO_OFFICE.minY;
-  const targetInCeoOffice =
-    finalX < CEO_OFFICE.maxX && finalY > CEO_OFFICE.minY;
-  if (inCeoOffice !== targetInCeoOffice) {
-    return {
-      x: targetInCeoOffice ? CEO_OFFICE.maxX - 60 : CEO_OFFICE.maxX + 60,
-      y: CEO_DOOR_Y,
-    };
-  }
-  return { x: finalX, y: finalY };
-}
-
 function makeRenderAgent(agent: OfficeAgent): RenderAgent {
   // Spawn near the entrance (south edge); the controller routes the agent to
   // its assigned desk from there.
@@ -253,6 +241,53 @@ export const AgentsLayer = memo(function AgentsLayer({
     }
   }, [agents]);
 
+  // Commanded missions (chat-driven world actions): put the agent on the trip
+  // route to the mission's destination, joining at the nearest waypoint so a
+  // mission can start from a desk, the rest room, or mid-trip anywhere.
+  useLayoutEffect(() => {
+    const offMission = onMission((mission) => {
+      const agent = lookupRef.current.get(mission.agentId);
+      if (!agent) {
+        emitMissionEvent({ type: "ended", mission });
+        return;
+      }
+      let ctrl = controllerRef.current.get(mission.agentId);
+      if (!ctrl) {
+        ctrl = { mode: "toSeat", goalKey: null };
+        controllerRef.current.set(mission.agentId, ctrl);
+      }
+      // A newer mission supersedes a running one for the same agent.
+      const prev = ctrl.trip?.mission;
+      if (prev && prev.id !== mission.id) {
+        emitMissionEvent({ type: "ended", mission: prev });
+      }
+      const route = getTripRoute(mission.dest);
+      const insideDest = (agent.place ?? "office") === mission.dest;
+      ctrl.mode = "trip";
+      ctrl.slide = undefined;
+      ctrl.trip = {
+        route,
+        phase: insideDest ? "visit" : "out",
+        idx: insideDest
+          ? route.points.length
+          : nearestRouteIdx(route, agent.x, agent.y),
+        wanderIdx: 0,
+        dwellUntil: 0,
+        endAt: 0,
+        mission,
+      };
+    });
+    const offComplete = onMissionComplete((missionId) => {
+      for (const ctrl of controllerRef.current.values()) {
+        if (ctrl.trip?.mission?.id === missionId) ctrl.trip.done = true;
+      }
+    });
+    return () => {
+      offMission();
+      offComplete();
+    };
+  }, []);
+
   useFrame((_, delta) => {
     const step = Math.min(delta, 0.05); // clamp big frame gaps
     const now = performance.now();
@@ -403,8 +438,9 @@ export const AgentsLayer = memo(function AgentsLayer({
         const trip = ctrl.trip;
         const { route } = trip;
         // Gateway came up mid-trip: turn around and walk the route home
-        // (never teleport or clip through walls).
-        if (working && trip.phase !== "back") {
+        // (never teleport or clip through walls). Commanded missions are
+        // exempt — being sent on an errand while working is the whole point.
+        if (working && !trip.mission && trip.phase !== "back") {
           trip.idx =
             trip.phase === "wander" ? route.points.length - 1 : trip.idx - 1;
           trip.phase = "back";
@@ -413,18 +449,73 @@ export const AgentsLayer = memo(function AgentsLayer({
         if (trip.phase === "out") {
           agent.place = classifyTripPlace(route, trip.idx);
           const [tx, ty] = route.points[trip.idx];
+          // Missions can start at any desk; legs still inside the office
+          // route through the partition/CEO doorways like seat walks do.
+          if (agent.place === "office") {
+            const wp = routeTarget(agent.x, agent.y, tx, ty);
+            if (wp.x !== tx || wp.y !== ty) {
+              walkStep(wp.x, wp.y, TRIP_WALK_SPEED, TRIP_ARRIVE_DISTANCE);
+              continue;
+            }
+          }
           if (walkStep(tx, ty, TRIP_WALK_SPEED, TRIP_ARRIVE_DISTANCE)) {
             trip.idx += 1;
             if (trip.idx >= route.points.length) {
-              trip.phase = "wander";
-              trip.wanderIdx = 0;
-              trip.dwellUntil = 0;
-              trip.endAt = now + randomBetween(...TRIP_WANDER_MS);
+              if (trip.mission) {
+                trip.phase = "visit";
+              } else {
+                trip.phase = "wander";
+                trip.wanderIdx = 0;
+                trip.dwellUntil = 0;
+                trip.endAt = now + randomBetween(...TRIP_WANDER_MS);
+              }
             }
           }
           continue;
         }
 
+        // Mission visit: walk to the interaction stop, report arrival, then
+        // hold (modal open) until completed or timed out, and head home.
+        if (trip.phase === "visit") {
+          agent.place = route.dest;
+          const mission = trip.mission;
+          if (
+            !mission ||
+            trip.done ||
+            (trip.holdUntil !== undefined && now >= trip.holdUntil)
+          ) {
+            if (mission) emitMissionEvent({ type: "ended", mission });
+            trip.mission = undefined;
+            trip.phase = "back";
+            trip.idx = route.points.length - 1;
+            continue;
+          }
+          const stop =
+            (mission.interaction && route.stops[mission.interaction.repId]) ||
+            route.wander[0] ||
+            route.points[route.points.length - 1];
+          if (!trip.arrived) {
+            if (
+              walkStep(
+                stop[0],
+                stop[1],
+                WALK_UNITS_PER_SEC,
+                TRIP_ARRIVE_DISTANCE,
+              )
+            ) {
+              trip.arrived = true;
+              trip.holdUntil =
+                now +
+                (mission.interaction ? MISSION_HOLD_MS : MISSION_LINGER_MS);
+              emitMissionEvent({ type: "arrived", mission });
+            }
+          } else {
+            agent.state = "standing";
+            resolvePhysics(false);
+          }
+          continue;
+        }
+
         if (trip.phase === "wander") {
           agent.place = route.dest;
           if (now >= trip.endAt) {
diff --git a/src/renderer/src/screens/Office/office3d/trips.ts b/src/renderer/src/screens/Office/office3d/trips.ts
index 1bc5221d6..5db2e883b 100644
--- a/src/renderer/src/screens/Office/office3d/trips.ts
+++ b/src/renderer/src/screens/Office/office3d/trips.ts
@@ -25,6 +25,13 @@ export interface TripRoute {
   exitOfficeIdx: number;
   /** Interior wander stops inside the destination. */
   wander: Array<[number, number]>;
+  /**
+   * Named interaction stops keyed by space-representative id ("bank-teller",
+   * "atm"). A commanded mission (see interactions/missionBus.ts) walks to its
+   * interaction's stop instead of wandering; missions without a stop use the
+   * first wander point.
+   */
+  stops: Record<string, [number, number]>;
 }
 
 // ── Tuning ─────────────────────────────────────────────────────────────────
@@ -70,6 +77,13 @@ const BANK_WANDER_WORLD: Array<[number, number]> = [
   [BANK_X + 5, BANK_Z],
 ];
 
+// Interaction stops reuse proven wander points (already collision-clear):
+// the spot in front of the teller counter and the east ATM row.
+const BANK_STOPS_WORLD: Record<string, [number, number]> = {
+  "bank-teller": [BANK_X, BANK_Z - 4.4],
+  atm: [BANK_X + 5, BANK_Z],
+};
+
 const SHOWROOM_OUTDOOR_WORLD: Array<[number, number]> = [
   [OFFICE_DOOR_X, SIDEWALK_Z], // straight out through the doorway
   [-20.7, SIDEWALK_Z],
@@ -95,17 +109,23 @@ function buildRoute(
   dest: TripRoute["dest"],
   outdoorWorld: Array<[number, number]>,
   wanderWorld: Array<[number, number]>,
+  stopsWorld: Record<string, [number, number]> = {},
 ): TripRoute {
+  const stops: Record<string, [number, number]> = {};
+  for (const [key, [wx, wz]] of Object.entries(stopsWorld)) {
+    stops[key] = worldToCanvas(wx, wz);
+  }
   return {
     dest,
     points: [...OFFICE_TO_DOOR, ...toCanvasPoints(outdoorWorld)],
     exitOfficeIdx: OFFICE_TO_DOOR.length,
     wander: toCanvasPoints(wanderWorld),
+    stops,
   };
 }
 
 export const TRIP_ROUTES: TripRoute[] = [
-  buildRoute("bank", BANK_OUTDOOR_WORLD, BANK_WANDER_WORLD),
+  buildRoute("bank", BANK_OUTDOOR_WORLD, BANK_WANDER_WORLD, BANK_STOPS_WORLD),
   buildRoute("showroom", SHOWROOM_OUTDOOR_WORLD, SHOWROOM_WANDER_WORLD),
 ];
 
@@ -114,6 +134,34 @@ export function pickTripRoute(rand: number): TripRoute {
   return TRIP_ROUTES[rand < 0.6 ? 0 : 1];
 }
 
+/** Route to a specific destination (commanded missions). */
+export function getTripRoute(dest: TripRoute["dest"]): TripRoute {
+  return TRIP_ROUTES.find((r) => r.dest === dest) ?? TRIP_ROUTES[0];
+}
+
+/**
+ * Index of the route waypoint nearest to a canvas position. A mission can
+ * start anywhere (desk, sidewalk, mid-trip elsewhere); joining the route at
+ * its nearest waypoint avoids walking back to the start first.
+ */
+export function nearestRouteIdx(
+  route: TripRoute,
+  x: number,
+  y: number,
+): number {
+  let best = 0;
+  let bestDist = Infinity;
+  for (let i = 0; i < route.points.length; i++) {
+    const [px, py] = route.points[i];
+    const d = (px - x) * (px - x) + (py - y) * (py - y);
+    if (d < bestDist) {
+      bestDist = d;
+      best = i;
+    }
+  }
+  return best;
+}
+
 /**
  * Where an agent is while heading to (or back from, walking the same points
  * in reverse) `route.points[idx]`.