diff --git a/apps/dashboard/src/components/workflow/DescribeWorkflow.tsx b/apps/dashboard/src/components/workflow/DescribeWorkflow.tsx
new file mode 100644
index 00000000..82763343
--- /dev/null
+++ b/apps/dashboard/src/components/workflow/DescribeWorkflow.tsx
@@ -0,0 +1,98 @@
+import { useState } from "react";
+import { Loader2, Sparkles } from "lucide-react";
+import { Button } from "@/components/ui/button";
+import type { Deployment } from "@/hooks/useReadyDeployments";
+import { INFERENCE_URL } from "@/lib/api";
+import { getToken } from "@/lib/tokenStore";
+import { generateWorkflow, type PlanSource } from "@/lib/workflow/generate";
+import { NODE_KINDS } from "@/lib/workflow/nodeKinds";
+import type { Workflow } from "@/lib/workflow/types";
+import { cn } from "@/lib/utils";
+
+const inputClass =
+  "w-full rounded-md border bg-background px-2 py-1.5 text-xs outline-none focus:ring-1 focus:ring-ember-500";
+
+// The planner call goes through the LLM node itself so it shares the sandbox auth and reasoning stripping.
+function complete(model: string) {
+  return async (system: string, user: string) => {
+    const out = await NODE_KINDS.llm.run(
+      { type: "text", text: user },
+      { id: "planner", kind: "llm", position: { x: 0, y: 0 }, config: { model, systemPrompt: system } },
+      { baseUrl: INFERENCE_URL, token: getToken(), fetch: window.fetch.bind(window), audioInputs: {} },
+    );
+    return out.type === "text" ? out.text : "";
+  };
+}
+
+export function DescribeWorkflow({
+  deployments,
+  onGenerated,
+}: {
+  deployments: Deployment[];
+  onGenerated: (workflow: Workflow) => void;
+}) {
+  const models = deployments.filter((d) => d.model_type === "inference" && d.modelName !== "-").map((d) => d.modelName);
+  const [description, setDescription] = useState("");
+  const [picked, setPicked] = useState("");
+  const [busy, setBusy] = useState(false);
+  const [source, setSource] = useState<PlanSource | null>(null);
+  const model = models.includes(picked) ? picked : models[0];
+
+  const submit = async () => {
+    if (!description.trim() || busy) return;
+    setBusy(true);
+    try {
+      const result = await generateWorkflow(description, model, model ? complete(model) : async () => "");
+      setSource(result.source);
+      onGenerated(result.workflow);
+    } finally {
+      setBusy(false);
+    }
+  };
+
+  return (
+    <section className="space-y-2">
+      <h3 className="text-xs font-medium uppercase text-muted-foreground">Describe a workflow</h3>
+      <textarea
+        rows={3}
+        value={description}
+        onChange={(e) => setDescription(e.target.value)}
+        onKeyDown={(e) => {
+          if (e.key === "Enter" && (e.metaKey || e.ctrlKey)) void submit();
+        }}
+        placeholder="A voice assistant that answers questions and talks back"
+        aria-label="Describe a workflow"
+        className={cn(inputClass, "resize-y")}
+      />
+      <select value={model ?? ""} onChange={(e) => setPicked(e.target.value)} aria-label="Planner model" className={inputClass}>
+        {models.length === 0 && <option value="">No inference deployments</option>}
+        {models.map((m) => (
+          <option key={m} value={m}>
+            {m}
+          </option>
+        ))}
+      </select>
+      <Button size="sm" className="w-full" onClick={() => void submit()} disabled={busy || !description.trim()}>
+        {busy ? <Loader2 className="mr-1.5 h-4 w-4 animate-spin" /> : <Sparkles className="mr-1.5 h-4 w-4" />}
+        Generate
+      </Button>
+      {source && (
+        <p
+          className="line-clamp-3 text-[11px] text-muted-foreground"
+          data-testid="plan-source"
+          title={source.kind === "fallback" ? source.reason : undefined}
+        >
+          {source.kind === "model" ? (
+            <>
+              Generated by <span className="font-mono text-foreground">{source.model}</span>
+            </>
+          ) : (
+            <>
+              <span className="text-foreground">Fallback planner</span>: {source.reason}
+            </>
+          )}
+        </p>
+      )}
+    </section>
+  );
+}
diff --git a/apps/dashboard/src/components/workflow/WorkflowNodeCard.test.tsx b/apps/dashboard/src/components/workflow/WorkflowNodeCard.test.tsx
index b08794d3..f9403f2c 100644
--- a/apps/dashboard/src/components/workflow/WorkflowNodeCard.test.tsx
+++ b/apps/dashboard/src/components/workflow/WorkflowNodeCard.test.tsx
@@ -20,6 +20,7 @@ function canvas(setAudio: CanvasContextValue["setAudio"]): CanvasContextValue {
   return {
     deployments: [], runs: {}, history: {}, audioInputs: {},
     setConfig: () => {}, setAudio, removeNode: () => {},
+    readiness: {}, deploy: () => {},
   };
 }
 
diff --git a/apps/dashboard/src/components/workflow/WorkflowNodeCard.tsx b/apps/dashboard/src/components/workflow/WorkflowNodeCard.tsx
index c1b53a15..073040fe 100644
--- a/apps/dashboard/src/components/workflow/WorkflowNodeCard.tsx
+++ b/apps/dashboard/src/components/workflow/WorkflowNodeCard.tsx
@@ -1,8 +1,9 @@
 import { useEffect, useMemo, useRef, useState } from "react";
 import { Handle, Position, type Node, type NodeProps } from "@xyflow/react";
-import { CheckCircle2, Loader2, Mic, Square, Upload, X, XCircle } from "lucide-react";
+import { CheckCircle2, CloudUpload, Loader2, Mic, Square, Upload, X, XCircle } from "lucide-react";
 import { cn } from "@/lib/utils";
 import { NODE_KINDS, type ConfigField } from "@/lib/workflow/nodeKinds";
+import type { Readiness } from "@/lib/workflow/readiness";
 import { stats } from "@/lib/workflow/stats";
 import type { NodeKind, NodeRun, Payload } from "@/lib/workflow/types";
 import { useCanvas } from "./canvasContext";
@@ -15,8 +16,9 @@ const inputClass =
 
 export function WorkflowNodeCard({ id, data, selected }: NodeProps<FlowNode>) {
   const spec = NODE_KINDS[data.kind];
-  const { runs } = useCanvas();
+  const { runs, readiness } = useCanvas();
   const run = runs[id];
+  const ready = readiness[id];
 
   return (
     <div
@@ -25,11 +27,13 @@ export function WorkflowNodeCard({ id, data, selected }: NodeProps<FlowNode>) {
         selected && "ring-2 ring-ember-500",
         run?.status === "running" && "border-ember-500",
         run?.status === "error" && "border-red-500",
+        !run && ready && ready.state !== "ready" && ready.state !== "selectModel" && "border-amber-500/70",
       )}
     >
       {spec.input && <Handle type="target" position={Position.Left} className="!h-3 !w-3 !bg-ember-500" />}
       <NodeHeader id={id} label={spec.label} run={run} ports={`${spec.input ?? "-"} -> ${spec.output ?? "-"}`} />
       <LatencyStats nodeId={id} />
+      {ready && <ReadinessBanner nodeId={id} readiness={ready} />}
       <div className="space-y-2 p-3">
         {data.kind === "audioInput" && <AudioSource nodeId={id} />}
         {spec.fields.map((field) => (
@@ -81,6 +85,39 @@ function Elapsed({ run }: { run: NodeRun }) {
   );
 }
 
+function ReadinessBanner({ nodeId, readiness }: { nodeId: string; readiness: Readiness }) {
+  const { deploy } = useCanvas();
+  if (readiness.state === "ready" || readiness.state === "selectModel" || readiness.state === "deployed") return null;
+  const { recommended } = readiness;
+  return (
+    <div className="space-y-1.5 border-b bg-amber-500/5 px-3 py-2 text-[11px]">
+      <div className="flex items-center justify-between gap-2">
+        <span className="font-medium text-amber-600 dark:text-amber-400">
+          {readiness.state === "needsDeployment" && "Needs deployment"}
+          {readiness.state === "deploying" && "Deploying..."}
+          {readiness.state === "waiting" && "Waiting for compute"}
+        </span>
+        {readiness.state === "deploying" ? (
+          <Loader2 className="h-3.5 w-3.5 animate-spin text-amber-500" />
+        ) : (
+          <button
+            type="button"
+            onClick={() => deploy(nodeId)}
+            className="nodrag flex items-center gap-1 rounded-md bg-ember-600 px-2 py-0.5 font-medium text-white hover:bg-ember-700"
+          >
+            <CloudUpload className="h-3 w-3" />
+            {readiness.state === "waiting" ? "Retry" : "Deploy"}
+          </button>
+        )}
+      </div>
+      <div className="text-muted-foreground">
+        Recommended <span className="font-mono text-foreground">{recommended.modelId}</span> on {recommended.engine}
+      </div>
+      {readiness.state === "waiting" && <p className="break-words text-red-500">{readiness.reason}</p>}
+    </div>
+  );
+}
+
 function LatencyStats({ nodeId }: { nodeId: string }) {
   const { history } = useCanvas();
   const s = stats(history[nodeId] ?? []);
diff --git a/apps/dashboard/src/components/workflow/canvasContext.ts b/apps/dashboard/src/components/workflow/canvasContext.ts
index e775e4fd..9ecd482b 100644
--- a/apps/dashboard/src/components/workflow/canvasContext.ts
+++ b/apps/dashboard/src/components/workflow/canvasContext.ts
@@ -1,5 +1,6 @@
 import { createContext, useContext } from "react";
 import type { Deployment } from "@/hooks/useReadyDeployments";
+import type { Readiness } from "@/lib/workflow/readiness";
 import type { History } from "@/lib/workflow/stats";
 import type { NodeRun } from "@/lib/workflow/types";
 
@@ -8,9 +9,11 @@ export interface CanvasContextValue {
   runs: Record<string, NodeRun>;
   history: History;
   audioInputs: Record<string, Blob>;
+  readiness: Record<string, Readiness>;
   setConfig: (nodeId: string, key: string, value: string) => void;
   setAudio: (nodeId: string, blob: Blob) => void;
   removeNode: (nodeId: string) => void;
+  deploy: (nodeId: string) => void;
 }
 
 export const CanvasContext = createContext<CanvasContextValue | null>(null);
diff --git a/apps/dashboard/src/components/workflow/useNodeDeploys.ts b/apps/dashboard/src/components/workflow/useNodeDeploys.ts
new file mode 100644
index 00000000..7448ac0a
--- /dev/null
+++ b/apps/dashboard/src/components/workflow/useNodeDeploys.ts
@@ -0,0 +1,55 @@
+import { useCallback, useState } from "react";
+import { useAuth } from "@/context/AuthContext";
+import { computeApi } from "@/lib/api";
+import { deployRequests, type CatalogModel, type PendingDeploy } from "@/lib/workflow/readiness";
+import { listPools } from "@/services/poolService";
+
+interface PreflightResponse {
+  ready: boolean;
+  checks: Array<{ passed: boolean; message?: string | null; check: string }>;
+}
+
+function errorMessage(err: unknown): string {
+  const body = (err as { response?: { data?: { detail?: unknown; message?: unknown } } }).response?.data;
+  const detail = body?.detail ?? body?.message;
+  if (typeof detail === "string") return detail;
+  return err instanceof Error ? err.message : "Request failed";
+}
+
+// Preflight, then deploy on the first usable pool, the same requests NewDeployment sends for a pool deploy.
+export function useNodeDeploys() {
+  const { user, organizations } = useAuth();
+  const [pending, setPending] = useState<Record<string, PendingDeploy>>({});
+
+  const set = useCallback((nodeId: string, p: PendingDeploy | null) => {
+    setPending((prev) => {
+      const next = { ...prev };
+      if (p) next[nodeId] = p;
+      else delete next[nodeId];
+      return next;
+    });
+  }, []);
+
+  const deploy = async (nodeId: string, entry: CatalogModel) => {
+    const orgId = user?.org_id || organizations?.[0]?.id;
+    if (!orgId) return set(nodeId, { status: "waiting", reason: "organization context missing" });
+    set(nodeId, { status: "deploying", deploymentName: entry.deploymentName });
+    try {
+      const pool = (await listPools(orgId)).find((p) => p.is_active && p.lifecycle_state !== "terminated");
+      if (!pool) return set(nodeId, { status: "waiting", reason: "no active compute pool" });
+      const req = deployRequests(entry, pool.pool_id, { orgId, ownerId: user?.user_id });
+      const { data } = await computeApi.post<PreflightResponse>("/deployment/preflight", req.preflight);
+      if (!data.ready) {
+        const failed = data.checks.filter((c) => !c.passed).map((c) => c.message || c.check);
+        return set(nodeId, { status: "waiting", reason: failed.join("; ") || "preflight failed" });
+      }
+      await computeApi.post("/deployment/deploy", req.deploy);
+    } catch (err) {
+      set(nodeId, { status: "waiting", reason: errorMessage(err) });
+    }
+  };
+
+  const clear = useCallback((nodeId: string) => set(nodeId, null), [set]);
+  const reset = useCallback(() => setPending({}), []);
+  return { pending, deploy, clear, reset };
+}
diff --git a/apps/dashboard/src/hooks/useReadyDeployments.ts b/apps/dashboard/src/hooks/useReadyDeployments.ts
index d2921aee..aede45c2 100644
--- a/apps/dashboard/src/hooks/useReadyDeployments.ts
+++ b/apps/dashboard/src/hooks/useReadyDeployments.ts
@@ -26,7 +26,8 @@ interface DeploymentResponse {
   }>;
 }
 
-export function useReadyDeployments() {
+// Pass a refetch interval to poll while a deployment is coming up.
+export function useReadyDeployments(refetchInterval: number | false = false) {
   return useQuery<Deployment[]>({
     queryKey: ["sandbox-deployments"],
     queryFn: async () => {
@@ -45,5 +46,6 @@ export function useReadyDeployments() {
         }));
     },
     staleTime: 30000,
+    refetchInterval,
   });
 }
diff --git a/apps/dashboard/src/lib/workflow/__tests__/engine.test.ts b/apps/dashboard/src/lib/workflow/__tests__/engine.test.ts
index 32c8fbbc..0ca13fa6 100644
--- a/apps/dashboard/src/lib/workflow/__tests__/engine.test.ts
+++ b/apps/dashboard/src/lib/workflow/__tests__/engine.test.ts
@@ -80,6 +80,13 @@ describe("autofillModels", () => {
     expect(filled.nodes.map((n) => n.config.model ?? null)).toEqual([null, "whisper-small", "llama-3-8b", "kokoro-tts", null]);
   });
 
+  it("leaves a model empty rather than binding a deployment for the other audio direction", () => {
+    const filled = autofillModels(TEMPLATES.bankingVoice.build(), [
+      { id: "k", name: "kokoro-tts", modelName: "kokoro-tts", model_type: "audio_generation", endpointUrl: "", status: "READY" },
+    ]);
+    expect(filled.nodes.map((n) => n.config.model ?? null)).toEqual([null, null, null, "kokoro-tts", null]);
+  });
+
   const audio = (modelName: string) => ({
     id: modelName, name: modelName, modelName, model_type: "audio_generation", endpointUrl: "", status: "READY",
   });
@@ -89,9 +96,9 @@ describe("autofillModels", () => {
     expect(filled.nodes.map((n) => n.config.model ?? null)).toEqual([null, "Speech Recognition", null, "Kokoro", null]);
   });
 
-  it("gives STT and TTS different deployments when no name matches", () => {
+  it("leaves STT and TTS empty when no name matches", () => {
     const filled = autofillModels(TEMPLATES.bankingVoice.build(), [audio("model-a"), audio("model-b")]);
-    expect(filled.nodes.map((n) => n.config.model ?? null)).toEqual([null, "model-a", null, "model-b", null]);
+    expect(filled.nodes.map((n) => n.config.model ?? null)).toEqual([null, null, null, null, null]);
   });
 });
 
diff --git a/apps/dashboard/src/lib/workflow/__tests__/generate.test.ts b/apps/dashboard/src/lib/workflow/__tests__/generate.test.ts
new file mode 100644
index 00000000..ebee5434
--- /dev/null
+++ b/apps/dashboard/src/lib/workflow/__tests__/generate.test.ts
@@ -0,0 +1,244 @@
+import { describe, expect, it, vi } from "vitest";
+import { extractJson, generateWorkflow, intentError, layout, planFromKeywords, plannerPrompt, validatePlan } from "../generate";
+import type { Workflow } from "../types";
+
+const kinds = (w: Workflow) => w.nodes.map((n) => n.kind);
+const pairs = (w: Workflow) => w.edges.map((e) => `${e.source}>${e.target}`);
+
+describe("plannerPrompt", () => {
+  it("lists every registry kind with its ports and plannable config", () => {
+    const prompt = plannerPrompt();
+    expect(prompt).toContain("- llm: Chat completion with a system prompt. Input: text. Output: text. Config: systemPrompt (system prompt).");
+    expect(prompt).toContain("- audioInput: Record from the mic or upload a file. Input: none. Output: audio. Config: none.");
+    expect(prompt).toContain("- textToSpeech: Synthesize speech with a TTS model. Input: text. Output: audio. Config: none.");
+    expect(prompt).not.toContain("model (model)");
+    expect(prompt).not.toContain("voice (voice)");
+  });
+});
+
+describe("extractJson", () => {
+  it("parses a bare object", () => {
+    expect(extractJson('{"a":1}')).toEqual({ a: 1 });
+  });
+
+  it("strips code fences and surrounding prose", () => {
+    expect(extractJson('Sure! Here it is:\n```json\n{"nodes":[{"id":"n1"}]}\n```\nEnjoy')).toEqual({ nodes: [{ id: "n1" }] });
+  });
+
+  it("takes only the first object and ignores braces inside strings", () => {
+    expect(extractJson('{"text":"a } b {"} {"second":true}')).toEqual({ text: "a } b {" });
+  });
+
+  it("returns null for no object or broken JSON", () => {
+    expect(extractJson("no json here")).toBeNull();
+    expect(extractJson('{"a": }')).toBeNull();
+    expect(extractJson('{"a": 1')).toBeNull();
+  });
+});
+
+describe("validatePlan", () => {
+  it("keeps a valid chain, drops model config, and lays it out in columns", () => {
+    const { workflow, errors } = validatePlan({
+      nodes: [
+        { id: "a", kind: "textInput", config: { text: "hi", bogus: "x" } },
+        { id: "b", kind: "llm", config: { model: "gpt-9", systemPrompt: "Be brief" } },
+        { id: "c", kind: "textOutput" },
+      ],
+      edges: [
+        { source: "a", target: "b" },
+        { source: "b", target: "c" },
+      ],
+    });
+    expect(errors).toEqual([]);
+    expect(workflow).toEqual({
+      nodes: [
+        { id: "a", kind: "textInput", position: { x: 0, y: 0 }, config: { text: "hi" } },
+        { id: "b", kind: "llm", position: { x: 280, y: 0 }, config: { systemPrompt: "Be brief" } },
+        { id: "c", kind: "textOutput", position: { x: 560, y: 0 }, config: {} },
+      ],
+      edges: [
+        { id: "e-a-b", source: "a", target: "b" },
+        { id: "e-b-c", source: "b", target: "c" },
+      ],
+    });
+  });
+
+  it("drops unknown kinds, duplicates and edges that fail connectionError", () => {
+    const { workflow, errors } = validatePlan({
+      nodes: [
+        { id: "a", kind: "audioInput" },
+        { id: "b", kind: "videoInput" },
+        { id: "c", kind: "textOutput" },
+        { id: "c", kind: "llm" },
+        { id: "d", kind: "speechToText" },
+      ],
+      edges: [
+        { source: "a", target: "c" },
+        { source: "a", target: "b" },
+        { source: "a", target: "d" },
+        { source: "d", target: "c" },
+        { source: "a", target: "d" },
+      ],
+    });
+    expect(kinds(workflow)).toEqual(["audioInput", "textOutput", "speechToText"]);
+    expect(pairs(workflow)).toEqual(["a>d", "d>c"]);
+    expect(errors).toEqual([
+      'Unknown node kind "videoInput"',
+      'Duplicate node id "c"',
+      "a -> c: Cannot connect audio output to text input",
+      "a -> b: Unknown node",
+      "a -> d: Speech to text already has an input",
+    ]);
+  });
+
+  it("reports when nothing usable remains", () => {
+    expect(validatePlan(null).errors).toEqual(["Reply is not an object with a nodes array"]);
+    expect(validatePlan({ nodes: [{ id: "x", kind: "nope" }] }).errors).toEqual(['Unknown node kind "nope"', "No valid nodes"]);
+    expect(validatePlan({ nodes: [{ id: "a", kind: "textInput" }, { id: "b", kind: "textOutput" }], edges: [] }).errors).toEqual([
+      "a is not on a path from an input to an output",
+      "b is not on a path from an input to an output",
+      "No valid nodes",
+    ]);
+  });
+
+  it("drops nodes off the input-to-output path and deployment-specific config", () => {
+    // Shape of a real small-model reply: a chain with no sink plus stray nodes.
+    const { workflow, errors } = validatePlan({
+      nodes: [
+        { id: "t", kind: "textInput", config: { text: "Hi" } },
+        { id: "l", kind: "llm" },
+        { id: "v", kind: "textToSpeech", config: { voice: "en-US-ElizabethVoice" } },
+        { id: "s", kind: "speechToText" },
+        { id: "o", kind: "textOutput" },
+        { id: "p", kind: "audioOutput" },
+      ],
+      edges: [
+        { source: "t", target: "l" },
+        { source: "l", target: "v" },
+        { source: "v", target: "p" },
+      ],
+    });
+    expect(kinds(workflow)).toEqual(["textInput", "llm", "textToSpeech", "audioOutput"]);
+    expect(workflow.nodes[2].config).toEqual({});
+    expect(errors).toEqual(["s is not on a path from an input to an output", "o is not on a path from an input to an output"]);
+  });
+});
+
+describe("layout", () => {
+  it("places nodes by longest path depth and stacks shared columns", () => {
+    const wf: Workflow = {
+      nodes: ["t", "l", "o", "s", "a"].map((id) => ({
+        id,
+        kind: "textInput",
+        position: { x: 9, y: 9 },
+        config: {},
+      })),
+      edges: [
+        { id: "1", source: "l", target: "o" },
+        { id: "2", source: "t", target: "l" },
+        { id: "3", source: "t", target: "s" },
+        { id: "4", source: "s", target: "a" },
+      ],
+    };
+    expect(Object.fromEntries(layout(wf).nodes.map((n) => [n.id, n.position]))).toEqual({
+      t: { x: 0, y: 0 },
+      l: { x: 280, y: 0 },
+      o: { x: 560, y: 0 },
+      s: { x: 280, y: 320 },
+      a: { x: 560, y: 320 },
+    });
+  });
+});
+
+describe("planFromKeywords", () => {
+  it("builds a voice pipeline for voice requests", () => {
+    const wf = planFromKeywords("A voice assistant that answers banking questions and talks back");
+    expect(kinds(wf)).toEqual(["audioInput", "speechToText", "llm", "textToSpeech", "audioOutput"]);
+    expect(pairs(wf)).toEqual([
+      "audioInput-1>speechToText-2",
+      "speechToText-2>llm-3",
+      "llm-3>textToSpeech-4",
+      "textToSpeech-4>audioOutput-5",
+    ]);
+    expect(wf.nodes.map((n) => n.position.x)).toEqual([0, 280, 560, 840, 1120]);
+    expect(wf.nodes[2].config.systemPrompt).toBe(
+      "You are an assistant for this use case: A voice assistant that answers banking questions and talks back\nReplies are spoken aloud, so answer in one to three short sentences with no markdown.",
+    );
+  });
+
+  it("transcribes", () => {
+    expect(kinds(planFromKeywords("Transcribe my meeting recordings"))).toEqual(["audioInput", "speechToText", "textOutput"]);
+  });
+
+  it("reads text aloud", () => {
+    expect(kinds(planFromKeywords("Read aloud a paragraph I paste"))).toEqual(["textInput", "textToSpeech", "audioOutput"]);
+    expect(kinds(planFromKeywords("speak text for me"))).toEqual(["textInput", "textToSpeech", "audioOutput"]);
+  });
+
+  it("defaults to a text chat", () => {
+    const wf = planFromKeywords("Summarize support tickets");
+    expect(kinds(wf)).toEqual(["textInput", "llm", "textOutput"]);
+    expect(wf.nodes[0].config).toEqual({ text: "Hello" });
+  });
+});
+
+describe("intentError", () => {
+  const plan = (k: string[]) => validatePlan({ nodes: k.map((kind, i) => ({ id: `n${i}`, kind })), edges: k.slice(1).map((_, i) => ({ source: `n${i}`, target: `n${i + 1}` })) }).workflow;
+
+  it("requires the modality the description names", () => {
+    expect(intentError("a voice bot that talks back", plan(["textInput", "textOutput"]))).toBe("The request needs audioInput and audioOutput");
+    expect(intentError("transcribe calls", plan(["audioInput", "speechToText", "textOutput"]))).toBeNull();
+    expect(intentError("read my notes aloud", plan(["textInput", "llm", "textOutput"]))).toBe("The request needs audioOutput");
+  });
+
+  it("accepts anything for descriptions without a keyword", () => {
+    expect(intentError("summarize tickets", plan(["audioInput", "speechToText", "textOutput"]))).toBeNull();
+  });
+});
+
+describe("generateWorkflow", () => {
+  const good = '{"nodes":[{"id":"i","kind":"textInput","config":{"text":"q"}},{"id":"o","kind":"textOutput"}],"edges":[{"source":"i","target":"o"}]}';
+
+  it("uses the model reply when valid", async () => {
+    const complete = vi.fn().mockResolvedValue("```json\n" + good + "\n```");
+    const result = await generateWorkflow("echo text", "bank-llm", complete);
+    expect(result.source).toEqual({ kind: "model", model: "bank-llm" });
+    expect(kinds(result.workflow)).toEqual(["textInput", "textOutput"]);
+    expect(complete).toHaveBeenCalledTimes(1);
+  });
+
+  it("retries once with the validation errors", async () => {
+    const complete = vi.fn().mockResolvedValueOnce('{"nodes":[{"id":"x","kind":"video"}]}').mockResolvedValueOnce(good);
+    const result = await generateWorkflow("echo text", "bank-llm", complete);
+    expect(result.source).toEqual({ kind: "model", model: "bank-llm" });
+    expect(complete).toHaveBeenCalledTimes(2);
+    expect(complete.mock.calls[1][1]).toBe(
+      'echo text\n\nYour previous reply was invalid: Unknown node kind "video"; No valid nodes. Reply with only the JSON object.',
+    );
+  });
+
+  it("rejects a valid plan that ignores the requested modality", async () => {
+    const complete = vi.fn().mockResolvedValue(good);
+    const result = await generateWorkflow("a voice assistant", "bank-llm", complete);
+    expect(result.source).toEqual({ kind: "fallback", reason: "The request needs audioInput and audioOutput" });
+    expect(complete.mock.calls[1][1]).toBe(
+      "a voice assistant\n\nYour previous reply was invalid: The request needs audioInput and audioOutput. Reply with only the JSON object.",
+    );
+    expect(kinds(result.workflow)).toEqual(["audioInput", "speechToText", "llm", "textToSpeech", "audioOutput"]);
+  });
+
+  it("falls back to the keyword planner after two bad replies", async () => {
+    const complete = vi.fn().mockResolvedValue("I cannot help with that");
+    const result = await generateWorkflow("transcribe calls", "bank-llm", complete);
+    expect(result.source).toEqual({ kind: "fallback", reason: "Reply is not an object with a nodes array" });
+    expect(kinds(result.workflow)).toEqual(["audioInput", "speechToText", "textOutput"]);
+    expect(complete).toHaveBeenCalledTimes(2);
+  });
+
+  it("falls back when the model call fails or no model exists", async () => {
+    const failed = await generateWorkflow("chat", "bank-llm", vi.fn().mockRejectedValue(new Error("API Error: 502")));
+    expect(failed.source).toEqual({ kind: "fallback", reason: "API Error: 502" });
+    const none = await generateWorkflow("chat", undefined, vi.fn());
+    expect(none.source).toEqual({ kind: "fallback", reason: "No inference deployment" });
+  });
+});
diff --git a/apps/dashboard/src/lib/workflow/__tests__/readiness.test.ts b/apps/dashboard/src/lib/workflow/__tests__/readiness.test.ts
new file mode 100644
index 00000000..e8cb41d5
--- /dev/null
+++ b/apps/dashboard/src/lib/workflow/__tests__/readiness.test.ts
@@ -0,0 +1,102 @@
+import { describe, expect, it } from "vitest";
+import type { Deployment } from "@/hooks/useReadyDeployments";
+import { MODEL_CATALOG, deployRequests, nodeReadiness, runBlocker } from "../readiness";
+import type { Workflow } from "../types";
+
+function dep(modelName: string, model_type: string): Deployment {
+  return { id: modelName, name: modelName, modelName, model_type, endpointUrl: "", status: "READY" };
+}
+
+const stt = { kind: "speechToText" as const, config: {} };
+const whisperCatalog = MODEL_CATALOG.speechToText!;
+
+describe("nodeReadiness", () => {
+  it("treats nodes without a model field, or with a model set, as ready", () => {
+    expect(nodeReadiness({ kind: "textInput", config: {} }, [], undefined)).toEqual({ state: "ready" });
+    expect(nodeReadiness({ kind: "llm", config: { model: "bank-llm" } }, [], undefined)).toEqual({ state: "ready" });
+  });
+
+  it("asks to select a model when a matching deployment exists", () => {
+    expect(nodeReadiness(stt, [dep("whisper-stt", "audio_generation")])).toEqual({ state: "selectModel" });
+    expect(nodeReadiness({ kind: "llm", config: {} }, [dep("bank-llm", "inference")])).toEqual({ state: "selectModel" });
+  });
+
+  it("needs deployment when only non-matching deployments exist", () => {
+    expect(nodeReadiness(stt, [dep("kokoro-tts", "audio_generation"), dep("bank-llm", "inference")])).toEqual({
+      state: "needsDeployment",
+      recommended: whisperCatalog,
+    });
+    expect(nodeReadiness({ kind: "textToSpeech", config: {} }, [])).toEqual({
+      state: "needsDeployment",
+      recommended: MODEL_CATALOG.textToSpeech,
+    });
+  });
+
+  it("follows the pending deploy through deploying, waiting and deployed", () => {
+    expect(nodeReadiness(stt, [], { status: "deploying", deploymentName: "whisper-tiny-stt" })).toEqual({
+      state: "deploying",
+      recommended: whisperCatalog,
+    });
+    expect(nodeReadiness(stt, [], { status: "waiting", reason: "no active compute pool" })).toEqual({
+      state: "waiting",
+      recommended: whisperCatalog,
+      reason: "no active compute pool",
+    });
+    expect(
+      nodeReadiness(stt, [dep("whisper-tiny-stt", "audio_generation")], { status: "deploying", deploymentName: "whisper-tiny-stt" }),
+    ).toEqual({ state: "deployed", model: "whisper-tiny-stt" });
+  });
+});
+
+describe("runBlocker", () => {
+  const wf = (configs: Array<Record<string, string>>): Workflow => ({
+    nodes: [
+      { id: "a", kind: "audioInput", position: { x: 0, y: 0 }, config: {} },
+      { id: "s", kind: "speechToText", position: { x: 0, y: 0 }, config: configs[0] },
+      { id: "l", kind: "llm", position: { x: 0, y: 0 }, config: configs[1] },
+    ],
+    edges: [],
+  });
+
+  it("is null when every node is ready", () => {
+    expect(runBlocker(wf([{ model: "w" }, { model: "l" }]), [], {})).toBeNull();
+  });
+
+  it("names the first blocked node and its reason", () => {
+    expect(runBlocker(wf([{}, { model: "l" }]), [], {})).toBe("Speech to text: Needs deployment");
+    expect(runBlocker(wf([{}, { model: "l" }]), [], { s: { status: "waiting", reason: "no active compute pool" } })).toBe(
+      "Speech to text: Waiting for compute: no active compute pool",
+    );
+    expect(runBlocker(wf([{ model: "w" }, {}]), [], { l: { status: "deploying", deploymentName: "qwen2-5-1-5b" } })).toBe(
+      "LLM: Deploying qwen2-5-1-5b",
+    );
+    expect(runBlocker(wf([{ model: "w" }, {}]), [dep("bank-llm", "inference")], {})).toBe("LLM: Select a model");
+  });
+});
+
+describe("deployRequests", () => {
+  it("builds the preflight and pool deploy payloads", () => {
+    const req = deployRequests(MODEL_CATALOG.llm!, "pool-1", { orgId: "org-1", ownerId: "user-1" });
+    expect(req.preflight).toEqual({
+      model_id: "qwen2.5:1.5b",
+      engine: "ollama",
+      gpu_per_replica: 1,
+      pool_id: "pool-1",
+      model_type: "inference",
+    });
+    expect(req.deploy).toMatchObject({
+      model_name: "qwen2-5-1-5b",
+      model_version: "latest",
+      replicas: 1,
+      gpu_per_replica: 1,
+      workload_type: "inference",
+      pool_id: "pool-1",
+      engine: "ollama",
+      model_type: "inference",
+      inference_model: "qwen2.5:1.5b",
+      owner_id: "user-1",
+      org_id: "org-1",
+    });
+    expect(deployRequests(whisperCatalog, "p", { orgId: "o" }).deploy.gpu_per_replica).toBe(0);
+  });
+});
diff --git a/apps/dashboard/src/lib/workflow/generate.ts b/apps/dashboard/src/lib/workflow/generate.ts
new file mode 100644
index 00000000..606a4933
--- /dev/null
+++ b/apps/dashboard/src/lib/workflow/generate.ts
@@ -0,0 +1,235 @@
+import { connectionError } from "./engine";
+import { NODE_KINDS } from "./nodeKinds";
+import type { ConfigField } from "./nodeKinds";
+import type { NodeKind, Workflow, WorkflowNode } from "./types";
+
+const COLUMN_WIDTH = 280;
+const ROW_HEIGHT = 320;
+
+// Only free text the user would write themselves; models and voice ids depend on what is deployed.
+function plannable(field: ConfigField): boolean {
+  return field.type !== "model" && !field.deploymentSpecific;
+}
+
+export function plannerPrompt(): string {
+  const kinds = (Object.keys(NODE_KINDS) as NodeKind[]).map((kind) => {
+    const spec = NODE_KINDS[kind];
+    const config = spec.fields.filter(plannable).map((f) => `${f.key} (${f.label.toLowerCase()})`);
+    return `- ${kind}: ${spec.description}. Input: ${spec.input ?? "none"}. Output: ${spec.output ?? "none"}. Config: ${config.join(", ") || "none"}.`;
+  });
+  return [
+    "You design pipelines for a node-based workflow editor. The only node kinds are:",
+    ...kinds,
+    "Rules: an edge connects a node's output to another node's input of the same type. A node has at most one incoming edge. No cycles. Every node must sit on a path from an input node (no input) to an output node (no output). Use audioInput when the user speaks and audioOutput when the app talks back. Only use the config keys listed.",
+    'Reply with only one JSON object, no prose and no code fences, shaped like {"nodes":[{"id":"n1","kind":"textInput","config":{"text":"Hi"}}],"edges":[{"source":"n1","target":"n2"}]}',
+  ].join("\n");
+}
+
+// Models wrap JSON in prose or code fences, so take the first balanced object instead of the whole reply.
+export function extractJson(text: string): unknown {
+  const body = text.replace(/```(?:json)?/gi, "");
+  const start = body.indexOf("{");
+  if (start === -1) return null;
+  let depth = 0;
+  let inString = false;
+  for (let i = start; i < body.length; i++) {
+    const ch = body[i];
+    if (inString) {
+      if (ch === "\\") i++;
+      else if (ch === '"') inString = false;
+    } else if (ch === '"') inString = true;
+    else if (ch === "{") depth++;
+    else if (ch === "}" && --depth === 0) {
+      try {
+        return JSON.parse(body.slice(start, i + 1));
+      } catch {
+        return null;
+      }
+    }
+  }
+  return null;
+}
+
+function isRecord(v: unknown): v is Record<string, unknown> {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+
+// Keeps every node and edge the registry and connectionError accept, and reports the rest.
+export function validatePlan(raw: unknown): { workflow: Workflow; errors: string[] } {
+  const errors: string[] = [];
+  const workflow: Workflow = { nodes: [], edges: [] };
+  if (!isRecord(raw) || !Array.isArray(raw.nodes)) return { workflow, errors: ["Reply is not an object with a nodes array"] };
+
+  for (const n of raw.nodes) {
+    if (!isRecord(n) || typeof n.id !== "string" || !n.id) {
+      errors.push("Node without an id");
+      continue;
+    }
+    if (typeof n.kind !== "string" || !(n.kind in NODE_KINDS)) {
+      errors.push(`Unknown node kind "${String(n.kind)}"`);
+      continue;
+    }
+    if (workflow.nodes.some((x) => x.id === n.id)) {
+      errors.push(`Duplicate node id "${n.id}"`);
+      continue;
+    }
+    const kind = n.kind as NodeKind;
+    const config: Record<string, string> = {};
+    for (const field of NODE_KINDS[kind].fields) {
+      const value = isRecord(n.config) ? n.config[field.key] : undefined;
+      if (plannable(field) && typeof value === "string") config[field.key] = value;
+    }
+    workflow.nodes.push({ id: n.id, kind, position: { x: 0, y: 0 }, config });
+  }
+
+  for (const e of Array.isArray(raw.edges) ? raw.edges : []) {
+    if (!isRecord(e) || typeof e.source !== "string" || typeof e.target !== "string") {
+      errors.push("Edge without source and target");
+      continue;
+    }
+    const error = connectionError(workflow, e.source, e.target);
+    if (error) errors.push(`${e.source} -> ${e.target}: ${error}`);
+    else workflow.edges.push({ id: `e-${e.source}-${e.target}`, source: e.source, target: e.target });
+  }
+
+  const complete = onCompletePath(workflow);
+  for (const n of workflow.nodes) if (!complete.has(n.id)) errors.push(`${n.id} is not on a path from an input to an output`);
+  const kept: Workflow = {
+    nodes: workflow.nodes.filter((n) => complete.has(n.id)),
+    edges: workflow.edges.filter((e) => complete.has(e.source) && complete.has(e.target)),
+  };
+  if (kept.nodes.length === 0) errors.push("No valid nodes");
+  return { workflow: layout(kept), errors };
+}
+
+// Nodes reachable from a source kind that can also reach a sink kind; anything else would never run usefully.
+function onCompletePath(workflow: Workflow): Set<string> {
+  const walk = (start: (n: WorkflowNode) => boolean, next: (id: string) => string[]) => {
+    const seen = new Set<string>();
+    const stack = workflow.nodes.filter(start).map((n) => n.id);
+    while (stack.length) {
+      const id = stack.pop()!;
+      if (seen.has(id)) continue;
+      seen.add(id);
+      stack.push(...next(id));
+    }
+    return seen;
+  };
+  const fromSource = walk(
+    (n) => NODE_KINDS[n.kind].input === null,
+    (id) => workflow.edges.filter((e) => e.source === id).map((e) => e.target),
+  );
+  const toSink = walk(
+    (n) => NODE_KINDS[n.kind].output === null,
+    (id) => workflow.edges.filter((e) => e.target === id).map((e) => e.source),
+  );
+  return new Set([...fromSource].filter((id) => toSink.has(id)));
+}
+
+// Column = longest path from a source, so every edge points rightwards.
+export function layout(workflow: Workflow): Workflow {
+  const column = new Map(workflow.nodes.map((n) => [n.id, 0]));
+  for (let pass = 0; pass < workflow.nodes.length; pass++) {
+    for (const e of workflow.edges) {
+      const next = (column.get(e.source) ?? 0) + 1;
+      if (next > (column.get(e.target) ?? 0)) column.set(e.target, next);
+    }
+  }
+  const rows = new Map<number, number>();
+  const nodes = workflow.nodes.map((n) => {
+    const col = column.get(n.id)!;
+    const row = rows.get(col) ?? 0;
+    rows.set(col, row + 1);
+    return { ...n, position: { x: col * COLUMN_WIDTH, y: row * ROW_HEIGHT } };
+  });
+  return { ...workflow, nodes };
+}
+
+type Step = { kind: NodeKind; config?: Record<string, string> };
+
+function chain(steps: Step[]): Workflow {
+  const nodes: WorkflowNode[] = steps.map((s, i) => ({
+    id: `${s.kind}-${i + 1}`,
+    kind: s.kind,
+    position: { x: 0, y: 0 },
+    config: s.config ?? {},
+  }));
+  const edges = nodes.slice(1).map((n, i) => ({ id: `e-${nodes[i].id}-${n.id}`, source: nodes[i].id, target: n.id }));
+  return layout({ nodes, edges });
+}
+
+const SPOKEN = "\nReplies are spoken aloud, so answer in one to three short sentences with no markdown.";
+
+// Checked in order; the first match wins. No match means a plain text chat.
+const RULES: Array<{ test: RegExp; steps: (systemPrompt: string) => Step[] }> = [
+  {
+    test: /transcri|dictat|caption/,
+    steps: () => [{ kind: "audioInput" }, { kind: "speechToText" }, { kind: "textOutput" }],
+  },
+  {
+    test: /read\b.*\baloud|out loud|speak (the |this )?text|text to speech|narrat/,
+    steps: () => [{ kind: "textInput", config: { text: "Hello from your workflow." } }, { kind: "textToSpeech" }, { kind: "audioOutput" }],
+  },
+  {
+    test: /voice|speak|call|talk|phone/,
+    steps: (systemPrompt) => [
+      { kind: "audioInput" },
+      { kind: "speechToText" },
+      { kind: "llm", config: { systemPrompt: systemPrompt + SPOKEN } },
+      { kind: "textToSpeech" },
+      { kind: "audioOutput" },
+    ],
+  },
+];
+
+function matchRule(description: string) {
+  const text = description.toLowerCase();
+  return RULES.find((r) => r.test.test(text));
+}
+
+// Deterministic last resort when no model reply is usable.
+export function planFromKeywords(description: string): Workflow {
+  const systemPrompt = `You are an assistant for this use case: ${description.trim()}`;
+  const rule = matchRule(description);
+  if (rule) return chain(rule.steps(systemPrompt));
+  return chain([{ kind: "textInput", config: { text: "Hello" } }, { kind: "llm", config: { systemPrompt } }, { kind: "textOutput" }]);
+}
+
+// When the description clearly names a modality, the model's plan must start and end with the same kinds.
+export function intentError(description: string, workflow: Workflow): string | null {
+  const rule = matchRule(description);
+  if (!rule) return null;
+  const steps = rule.steps("");
+  const missing = [steps[0].kind, steps[steps.length - 1].kind].filter((k) => !workflow.nodes.some((n) => n.kind === k));
+  return missing.length ? `The request needs ${missing.join(" and ")}` : null;
+}
+
+export type PlanSource = { kind: "model"; model: string } | { kind: "fallback"; reason: string };
+
+export async function generateWorkflow(
+  description: string,
+  model: string | undefined,
+  complete: (system: string, user: string) => Promise<string>,
+): Promise<{ workflow: Workflow; source: PlanSource }> {
+  if (!model) return { workflow: planFromKeywords(description), source: { kind: "fallback", reason: "No inference deployment" } };
+  const system = plannerPrompt();
+  let reason: string;
+  try {
+    const attempt = async (prompt: string) => {
+      const plan = validatePlan(extractJson(await complete(system, prompt)));
+      const found = plan.workflow.nodes.length > 0;
+      const intent = found ? intentError(description, plan.workflow) : null;
+      return { workflow: plan.workflow, errors: intent ? [...plan.errors, intent] : plan.errors, ok: found && !intent };
+    };
+    const first = await attempt(description);
+    if (first.ok) return { workflow: first.workflow, source: { kind: "model", model } };
+    const second = await attempt(
+      `${description}\n\nYour previous reply was invalid: ${first.errors.join("; ")}. Reply with only the JSON object.`,
+    );
+    if (second.ok) return { workflow: second.workflow, source: { kind: "model", model } };
+    reason = second.errors.join("; ");
+  } catch (err) {
+    reason = err instanceof Error ? err.message : String(err);
+  }
+  return { workflow: planFromKeywords(description), source: { kind: "fallback", reason } };
+}
diff --git a/apps/dashboard/src/lib/workflow/nodeKinds.ts b/apps/dashboard/src/lib/workflow/nodeKinds.ts
index 3297d422..de8b99ca 100644
--- a/apps/dashboard/src/lib/workflow/nodeKinds.ts
+++ b/apps/dashboard/src/lib/workflow/nodeKinds.ts
@@ -1,3 +1,4 @@
+import type { Deployment } from "@/hooks/useReadyDeployments";
 import { parseThinking } from "@/lib/parseThinking";
 import type { NodeKind, Payload, PortType, RunContext, WorkflowNode } from "./types";
 
@@ -10,7 +11,14 @@ export type ConfigField =
       // STT and TTS share the audio_generation model_type, so the name is the only hint for auto-selection.
       prefer?: RegExp;
     }
-  | { key: string; label: string; type: "text" | "textarea"; placeholder?: string };
+  | {
+      key: string;
+      label: string;
+      type: "text" | "textarea";
+      placeholder?: string;
+      // Values that only make sense for one deployment (voice ids) are left to the user, not the planner.
+      deploymentSpecific?: boolean;
+    };
 
 export interface NodeKindSpec {
   label: string;
@@ -50,11 +58,21 @@ function requireModel(node: WorkflowNode): string {
   return model;
 }
 
+const DEFAULT_VOICE = "af_heart";
+
 function audioFileName(blob: Blob): string {
   const subtype = blob.type.split("/")[1]?.split(";")[0];
   return `audio.${subtype === "mpeg" ? "mp3" : subtype || "webm"}`;
 }
 
+// Deployments a model field can use. STT and TTS share a model_type, so a field with a name hint only takes
+// matching names: binding a TTS model to an STT node would fail at run time.
+export function matchingDeployments(field: Extract<ConfigField, { type: "model" }>, deployments: Deployment[]): Deployment[] {
+  return deployments.filter(
+    (d) => d.model_type === field.modelType && d.modelName !== "-" && (!field.prefer || field.prefer.test(d.modelName)),
+  );
+}
+
 export const NODE_KINDS: Record<NodeKind, NodeKindSpec> = {
   audioInput: {
     label: "Audio input",
@@ -145,14 +163,15 @@ export const NODE_KINDS: Record<NodeKind, NodeKindSpec> = {
         modelType: "audio_generation",
         prefer: /tts|text.?to.?speech|kokoro|bark|piper|orpheus/i,
       },
-      { key: "voice", label: "Voice", type: "text", placeholder: "default" },
+      { key: "voice", label: "Voice", type: "text", placeholder: DEFAULT_VOICE, deploymentSpecific: true },
     ],
     run: async (input, node, ctx) => {
       const text = expectText(input);
-      const voice = node.config.voice?.trim();
+      // The speech API rejects a missing voice; af_heart is Kokoro's default and Piper ignores the name.
+      const voice = node.config.voice?.trim() || DEFAULT_VOICE;
       const res = await inference(ctx, "/v1/audio/speech", {
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ model: requireModel(node), input: text, ...(voice ? { voice } : {}) }),
+        body: JSON.stringify({ model: requireModel(node), input: text, voice }),
       });
       return { type: "audio", blob: await res.blob() };
     },
diff --git a/apps/dashboard/src/lib/workflow/readiness.ts b/apps/dashboard/src/lib/workflow/readiness.ts
new file mode 100644
index 00000000..16f36893
--- /dev/null
+++ b/apps/dashboard/src/lib/workflow/readiness.ts
@@ -0,0 +1,130 @@
+import type { Deployment } from "@/hooks/useReadyDeployments";
+import { NODE_KINDS, matchingDeployments } from "./nodeKinds";
+import type { NodeKind, Workflow, WorkflowNode } from "./types";
+
+export interface CatalogModel {
+  modelId: string;
+  engine: string;
+  modelType: "inference" | "audio_generation";
+  // Becomes the deployment's model_name, which is also the name the inference API routes on.
+  deploymentName: string;
+  job: Record<string, unknown>;
+}
+
+const speaches = (modelId: string) => ({
+  model_id: modelId,
+  engine: "speaches",
+  image: "ghcr.io/speaches-ai/speaches:latest-cpu",
+  env: { PRELOAD_MODELS: JSON.stringify([modelId]) },
+  expose: [{ port: 8000, type: "http", health_checks: [{ path: "/health", type: "http", method: "GET", expected_status: 200 }] }],
+  gpu: false,
+});
+
+export const MODEL_CATALOG: Partial<Record<NodeKind, CatalogModel>> = {
+  speechToText: {
+    modelId: "Systran/faster-whisper-tiny.en",
+    engine: "speaches",
+    modelType: "audio_generation",
+    deploymentName: "whisper-tiny-stt",
+    job: speaches("Systran/faster-whisper-tiny.en"),
+  },
+  textToSpeech: {
+    modelId: "speaches-ai/piper-en_US-amy-medium",
+    engine: "speaches",
+    modelType: "audio_generation",
+    deploymentName: "piper-amy-tts",
+    job: speaches("speaches-ai/piper-en_US-amy-medium"),
+  },
+  llm: {
+    modelId: "qwen2.5:1.5b",
+    engine: "ollama",
+    modelType: "inference",
+    deploymentName: "qwen2-5-1-5b",
+    job: {
+      model_id: "qwen2.5:1.5b",
+      engine: "ollama",
+      image: "ollama/ollama:latest",
+      cmd: ["serve"],
+      expose: [{ port: 11434, type: "http" }],
+      gpu: true,
+    },
+  },
+};
+
+// Deploy attempt the canvas started for a node; lives in UI state, never in the saved workflow.
+export type PendingDeploy = { status: "deploying"; deploymentName: string } | { status: "waiting"; reason: string };
+
+export type Readiness =
+  | { state: "ready" }
+  | { state: "selectModel" }
+  | { state: "needsDeployment"; recommended: CatalogModel }
+  | { state: "deploying"; recommended: CatalogModel }
+  | { state: "waiting"; recommended: CatalogModel; reason: string }
+  // The node's own deployment came up; the canvas selects it and the node becomes ready.
+  | { state: "deployed"; model: string };
+
+export function nodeReadiness(
+  node: Pick<WorkflowNode, "kind" | "config">,
+  deployments: Deployment[],
+  pending?: PendingDeploy,
+): Readiness {
+  const field = NODE_KINDS[node.kind].fields.find((f) => f.type === "model");
+  if (!field || field.type !== "model" || node.config[field.key]) return { state: "ready" };
+  const recommended = MODEL_CATALOG[node.kind];
+  if (pending?.status === "deploying" && deployments.some((d) => d.modelName === pending.deploymentName)) {
+    return { state: "deployed", model: pending.deploymentName };
+  }
+  if (matchingDeployments(field, deployments).length > 0 || !recommended) return { state: "selectModel" };
+  if (pending?.status === "deploying") return { state: "deploying", recommended };
+  if (pending?.status === "waiting") return { state: "waiting", recommended, reason: pending.reason };
+  return { state: "needsDeployment", recommended };
+}
+
+export function readinessMessage(r: Readiness): string | null {
+  switch (r.state) {
+    case "ready":
+    case "deployed":
+      return null;
+    case "selectModel":
+      return "Select a model";
+    case "needsDeployment":
+      return "Needs deployment";
+    case "deploying":
+      return `Deploying ${r.recommended.deploymentName}`;
+    case "waiting":
+      return `Waiting for compute: ${r.reason}`;
+  }
+}
+
+export function runBlocker(
+  workflow: Workflow,
+  deployments: Deployment[],
+  pending: Record<string, PendingDeploy>,
+): string | null {
+  for (const node of workflow.nodes) {
+    const message = readinessMessage(nodeReadiness(node, deployments, pending[node.id]));
+    if (message) return `${NODE_KINDS[node.kind].label}: ${message}`;
+  }
+  return null;
+}
+
+export function deployRequests(entry: CatalogModel, poolId: string, ids: { orgId: string; ownerId?: string }) {
+  return {
+    preflight: { model_id: entry.modelId, engine: entry.engine, gpu_per_replica: 1, pool_id: poolId, model_type: entry.modelType },
+    deploy: {
+      model_name: entry.deploymentName,
+      model_version: "latest",
+      replicas: 1,
+      gpu_per_replica: entry.job.gpu ? 1 : 0,
+      workload_type: "inference",
+      pool_id: poolId,
+      engine: entry.engine,
+      model_type: entry.modelType,
+      configuration: entry.job,
+      job_definition: entry.job,
+      inference_model: entry.modelId,
+      owner_id: ids.ownerId,
+      org_id: ids.orgId,
+    },
+  };
+}
diff --git a/apps/dashboard/src/lib/workflow/templates.ts b/apps/dashboard/src/lib/workflow/templates.ts
index 108ff089..cb3f77dc 100644
--- a/apps/dashboard/src/lib/workflow/templates.ts
+++ b/apps/dashboard/src/lib/workflow/templates.ts
@@ -1,5 +1,5 @@
 import type { Deployment } from "@/hooks/useReadyDeployments";
-import { NODE_KINDS } from "./nodeKinds";
+import { NODE_KINDS, matchingDeployments } from "./nodeKinds";
 import type { NodeKind, Workflow } from "./types";
 
 export const BANKING_SYSTEM_PROMPT = `You are the voice assistant for Inferia Bank, a fictional bank used for a product demo. Your answers are spoken aloud, so reply in one to three short sentences with no markdown or lists.
@@ -47,25 +47,16 @@ export const TEMPLATES: Record<string, { label: string; build: () => Workflow }>
   },
 };
 
-// Fill empty model fields with the first ready deployment of the matching type.
+// Fill empty model fields with the first matching ready deployment.
 export function autofillModels(workflow: Workflow, deployments: Deployment[]): Workflow {
-  // STT and TTS share a model_type, so a deployment given to one node isn't offered to the other.
-  const used = new Set(
-    workflow.nodes.flatMap((n) => NODE_KINDS[n.kind].fields.filter((f) => f.type === "model").map((f) => n.config[f.key])),
-  );
   return {
     ...workflow,
     nodes: workflow.nodes.map((node) => {
       const config = { ...node.config };
       for (const field of NODE_KINDS[node.kind].fields) {
         if (field.type !== "model" || config[field.key]) continue;
-        const candidates = deployments.filter((d) => d.model_type === field.modelType && d.modelName !== "-");
-        const unused = candidates.filter((d) => !used.has(d.modelName));
-        const match = unused.find((d) => field.prefer?.test(d.modelName)) ?? unused[0] ?? (field.prefer ? undefined : candidates[0]);
-        if (match) {
-          config[field.key] = match.modelName;
-          used.add(match.modelName);
-        }
+        const match = matchingDeployments(field, deployments)[0];
+        if (match) config[field.key] = match.modelName;
       }
       return { ...node, config };
     }),
diff --git a/apps/dashboard/src/pages/Workflows.tsx b/apps/dashboard/src/pages/Workflows.tsx
index ca9b04a0..4727773c 100644
--- a/apps/dashboard/src/pages/Workflows.tsx
+++ b/apps/dashboard/src/pages/Workflows.tsx
@@ -1,4 +1,4 @@
-import { useCallback, useRef, useState, type DragEvent } from "react";
+import { useCallback, useMemo, useRef, useState, type DragEvent } from "react";
 import {
   Background,
   Controls,
@@ -18,13 +18,16 @@ import { toast } from "sonner";
 import { Button } from "@/components/ui/button";
 import { useTheme } from "@/components/theme-provider";
 import { CanvasContext, type CanvasContextValue } from "@/components/workflow/canvasContext";
+import { DescribeWorkflow } from "@/components/workflow/DescribeWorkflow";
 import { RunSummary } from "@/components/workflow/RunSummary";
+import { useNodeDeploys } from "@/components/workflow/useNodeDeploys";
 import { WorkflowNodeCard, type FlowNode } from "@/components/workflow/WorkflowNodeCard";
 import { useReadyDeployments, type Deployment } from "@/hooks/useReadyDeployments";
 import { INFERENCE_URL } from "@/lib/api";
 import { getToken } from "@/lib/tokenStore";
 import { connectionError, runWorkflow } from "@/lib/workflow/engine";
 import { NODE_KINDS } from "@/lib/workflow/nodeKinds";
+import { MODEL_CATALOG, nodeReadiness, runBlocker } from "@/lib/workflow/readiness";
 import { recordRuns } from "@/lib/workflow/stats";
 import { deleteWorkflow, loadHistory, loadSavedWorkflows, saveHistory, saveWorkflow } from "@/lib/workflow/storage";
 import { TEMPLATES, autofillModels } from "@/lib/workflow/templates";
@@ -73,8 +76,11 @@ export default function Workflows() {
   );
 }
 
-function Canvas({ deployments }: { deployments: Deployment[] }) {
+function Canvas({ deployments: initialDeployments }: { deployments: Deployment[] }) {
   const { theme } = useTheme();
+  const { pending, deploy, clear, reset } = useNodeDeploys();
+  const deploying = Object.values(pending).some((p) => p.status === "deploying");
+  const { data: deployments = initialDeployments } = useReadyDeployments(deploying ? 5000 : false);
   const { screenToFlowPosition, deleteElements, fitView } = useReactFlow<FlowNode>();
   const [initial] = useState(() => toFlow(autofillModels(TEMPLATES.bankingVoice.build(), deployments)));
   const [nodes, setNodes, onNodesChange] = useNodesState<FlowNode>(initial.nodes);
@@ -88,6 +94,27 @@ function Canvas({ deployments }: { deployments: Deployment[] }) {
   const [name, setName] = useState("");
   const counter = useRef(0);
 
+  const readiness = useMemo(
+    () => Object.fromEntries(nodes.map((n) => [n.id, nodeReadiness(n.data, deployments, pending[n.id])])),
+    [nodes, deployments, pending],
+  );
+  const blocker = runBlocker(fromFlow(nodes, edges), deployments, pending);
+
+  const setConfig = useCallback(
+    (nodeId: string, key: string, value: string) =>
+      setNodes((prev) =>
+        prev.map((n) => (n.id === nodeId ? { ...n, data: { ...n.data, config: { ...n.data.config, [key]: value } } } : n)),
+      ),
+    [setNodes],
+  );
+
+  // A node's own deployment came up: select it during render so the node is ready on this same pass.
+  for (const [id, r] of Object.entries(readiness)) {
+    if (r.state !== "deployed") continue;
+    setConfig(id, "model", r.model);
+    clear(id);
+  }
+
   const loadWorkflow = useCallback(
     (workflow: Workflow) => {
       const flow = toFlow(workflow);
@@ -98,9 +125,10 @@ function Canvas({ deployments }: { deployments: Deployment[] }) {
       setTiming(null);
       setHistory({});
       saveHistory({});
+      reset();
       requestAnimationFrame(() => fitView({ padding: 0.2 }));
     },
-    [setNodes, setEdges, fitView],
+    [setNodes, setEdges, fitView, reset],
   );
 
   const run = async (inputs = audioInputs) => {
@@ -108,6 +136,7 @@ function Canvas({ deployments }: { deployments: Deployment[] }) {
       toast.info("A run is already in progress");
       return;
     }
+    if (blocker) return void toast.error(blocker);
     setRunning(true);
     const startedAt = performance.now();
     setTiming({ startedAt, endedAt: null });
@@ -160,16 +189,19 @@ function Canvas({ deployments }: { deployments: Deployment[] }) {
     runs,
     history,
     audioInputs,
-    setConfig: (nodeId, key, value) =>
-      setNodes((prev) =>
-        prev.map((n) => (n.id === nodeId ? { ...n, data: { ...n.data, config: { ...n.data.config, [key]: value } } } : n)),
-      ),
+    readiness,
+    setConfig,
     setAudio: (nodeId, blob) => {
       const next = { ...audioInputs, [nodeId]: blob };
       setAudioInputs(next);
       void run(next);
     },
     removeNode: (nodeId) => void deleteElements({ nodes: [{ id: nodeId }] }),
+    deploy: (nodeId) => {
+      const kind = nodes.find((n) => n.id === nodeId)?.data.kind;
+      const entry = kind && MODEL_CATALOG[kind];
+      if (entry) void deploy(nodeId, entry);
+    },
   };
 
   const onSave = () => {
@@ -183,6 +215,8 @@ function Canvas({ deployments }: { deployments: Deployment[] }) {
   return (
     <div className="flex min-h-0 flex-1 flex-col gap-4 lg:flex-row">
       <aside className="flex shrink-0 flex-col gap-4 overflow-y-auto rounded-xl border bg-card p-3 shadow-sm lg:w-60">
+        <DescribeWorkflow deployments={deployments} onGenerated={(w) => loadWorkflow(autofillModels(w, deployments))} />
+
         <section className="space-y-2">
           <h3 className="text-xs font-medium uppercase text-muted-foreground">Templates</h3>
           {Object.entries(TEMPLATES).map(([key, t]) => (
@@ -267,7 +301,12 @@ function Canvas({ deployments }: { deployments: Deployment[] }) {
           <Button variant="outline" size="sm" onClick={() => loadWorkflow({ nodes: [], edges: [] })}>
             Clear
           </Button>
-          <Button size="sm" onClick={() => void run()} disabled={running || nodes.length === 0}>
+          {blocker && !running && (
+            <span className="max-w-64 truncate rounded-md border bg-card px-2 py-1.5 text-xs text-muted-foreground" title={blocker}>
+              {blocker}
+            </span>
+          )}
+          <Button size="sm" onClick={() => void run()} disabled={running || nodes.length === 0 || blocker !== null} title={blocker ?? undefined}>
             {running ? <Loader2 className="mr-1.5 h-4 w-4 animate-spin" /> : <Play className="mr-1.5 h-4 w-4" />}
             Run
           </Button>