diff --git a/packages/scout-agent/.gitignore b/packages/scout-agent/.gitignore
index a6dec3a..50872e7 100644
--- a/packages/scout-agent/.gitignore
+++ b/packages/scout-agent/.gitignore
@@ -1 +1,5 @@
 .blink
+**/.claude
+dist
+node_modules
+*.tgz
\ No newline at end of file
diff --git a/packages/scout-agent/README.md b/packages/scout-agent/README.md
index f9414f3..1aafefd 100644
--- a/packages/scout-agent/README.md
+++ b/packages/scout-agent/README.md
@@ -66,14 +66,14 @@ All integrations are optional - include only what you need.
 
 ### ScoutOptions
 
-| Option      | Type                   | Required | Description                             |
-| ----------- | ---------------------- | -------- | --------------------------------------- |
-| `agent`     | `blink.Agent<Message>` | Yes      | Blink agent instance                    |
-| `github`    | `GitHubConfig`         | No       | GitHub App configuration                |
-| `slack`     | `SlackConfig`          | No       | Slack App configuration                 |
-| `webSearch` | `WebSearchConfig`      | No       | Exa web search configuration            |
-| `compute`   | `ComputeConfig`        | No       | Docker or Daytona compute configuration |
-| `logger`    | `Logger`               | No       | Custom logger instance                  |
+| Option      | Type                   | Required | Description                                     |
+| ----------- | ---------------------- | -------- | ----------------------------------------------- |
+| `agent`     | `blink.Agent<Message>` | Yes      | Blink agent instance                            |
+| `github`    | `GitHubConfig`         | No       | GitHub App configuration                        |
+| `slack`     | `SlackConfig`          | No       | Slack App configuration                         |
+| `webSearch` | `WebSearchConfig`      | No       | Exa web search configuration                    |
+| `compute`   | `ComputeConfig`        | No       | Docker, Daytona, or Coder compute configuration |
+| `logger`    | `Logger`               | No       | Custom logger instance                          |
 
 ### GitHub
 
@@ -151,6 +151,23 @@ Execute code in isolated environments:
 }
 ```
 
+**Coder (self-hosted workspaces):**
+
+```typescript
+{
+  type: "coder",
+  options: {
+    coderUrl: string                  // Coder deployment URL (e.g., https://coder.example.com)
+    sessionToken: string              // Coder session token for authentication
+    template: string                  // Template name to create workspaces from
+    computeServerPort?: number        // Port for compute server (default: 22137)
+    presetName?: string               // Optional preset name for workspace creation
+    richParameters?: Array<{ name: string; value: string }> // Optional template parameters
+    startTimeoutSeconds?: number      // Workspace start timeout (default: 300)
+  }
+}
+```
+
 ## API Reference
 
 ### Scout Class
diff --git a/packages/scout-agent/agent.ts b/packages/scout-agent/agent.ts
index f59da0f..42d278a 100644
--- a/packages/scout-agent/agent.ts
+++ b/packages/scout-agent/agent.ts
@@ -5,6 +5,13 @@ import { type Message, Scout } from "./lib";
 
 export const agent = new blink.Agent<Message>();
 
+const ensure = (value: string | undefined): string => {
+  if (value === undefined) {
+    throw new Error("value is undefined");
+  }
+  return value;
+};
+
 const scout = new Scout({
   agent,
   github: {
@@ -20,7 +27,13 @@ const scout = new Scout({
     exaApiKey: process.env.EXA_API_KEY,
   },
   compute: {
-    type: "docker",
+    type: "coder",
+    options: {
+      url: ensure(process.env.CODER_URL),
+      sessionToken: ensure(process.env.CODER_SESSION_TOKEN),
+      template: ensure(process.env.CODER_TEMPLATE),
+      presetName: ensure(process.env.CODER_PRESET_NAME),
+    },
   },
 });
 
@@ -39,7 +52,7 @@ agent.on("chat", async ({ id, messages }) => {
   const params = await scout.buildStreamTextParams({
     messages,
     chatID: id,
-    model: "anthropic/claude-sonnet-4.5",
+    model: "anthropic/claude-opus-4.5",
     providerOptions: { anthropic: { cacheControl: { type: "ephemeral" } } },
     tools: {
       get_favorite_color: tool({
diff --git a/packages/scout-agent/lib/compute/coder/index.test.ts b/packages/scout-agent/lib/compute/coder/index.test.ts
new file mode 100644
index 0000000..600b9ed
--- /dev/null
+++ b/packages/scout-agent/lib/compute/coder/index.test.ts
@@ -0,0 +1,675 @@
+import { describe, expect, mock, test } from "bun:test";
+import {
+  baseCoderTestOptions,
+  createMockCoderClient,
+  createMockComputeServer,
+  mockCoderPreset,
+  mockCoderWorkspace,
+  mockCoderWorkspaceBuild,
+  noopLogger,
+} from "../test-utils";
+import { getCoderWorkspaceClient, initializeCoderWorkspace } from "./index";
+
+describe("initializeCoderWorkspace", () => {
+  describe("existing workspace - running state", () => {
+    test("reuses running workspace with connected agent", async () => {
+      using computeServer = createMockComputeServer();
+
+      const mockClient = createMockCoderClient({
+        getAppHost: mock(() =>
+          Promise.resolve(`localhost:${computeServer.port}`)
+        ),
+      });
+
+      const result = await initializeCoderWorkspace(
+        noopLogger,
+        { ...baseCoderTestOptions, client: mockClient },
+        {
+          workspaceId: "ws-123",
+          workspaceName: "test-workspace",
+          ownerName: "testuser",
+          agentName: "main",
+        }
+      );
+
+      expect(result.message).toContain("already initialized");
+      expect(result.workspaceInfo.workspaceId).toBe("ws-123");
+      expect(result.workspaceInfo.agentName).toBe("main");
+      expect(mockClient.createWorkspaceBuild).not.toHaveBeenCalled();
+      expect(mockClient.createWorkspace).not.toHaveBeenCalled();
+    });
+
+    test("falls through to create new when agent not connected", async () => {
+      using computeServer = createMockComputeServer();
+
+      let getWorkspaceCallCount = 0;
+      const mockClient = createMockCoderClient({
+        getWorkspace: mock(() => {
+          getWorkspaceCallCount++;
+          // First call: existing workspace with disconnected agent
+          if (getWorkspaceCallCount === 1) {
+            return Promise.resolve(
+              mockCoderWorkspace({
+                latest_build: mockCoderWorkspaceBuild({
+                  status: "running",
+                  resources: [
+                    {
+                      id: "res-123",
+                      name: "main",
+                      type: "docker_container",
+                      agents: [
+                        {
+                          id: "agent-123",
+                          name: "main",
+                          status: "disconnected",
+                        },
+                      ],
+                    },
+                  ],
+                }),
+              })
+            );
+          }
+          // Subsequent calls: newly created workspace is running with connected agent
+          return Promise.resolve(mockCoderWorkspace({ id: "ws-new" }));
+        }),
+        createWorkspace: mock(() =>
+          Promise.resolve(mockCoderWorkspace({ id: "ws-new" }))
+        ),
+        getAppHost: mock(() =>
+          Promise.resolve(`localhost:${computeServer.port}`)
+        ),
+      });
+
+      const result = await initializeCoderWorkspace(
+        noopLogger,
+        {
+          ...baseCoderTestOptions,
+          template: "test-template",
+          client: mockClient,
+        },
+        {
+          workspaceId: "ws-123",
+          workspaceName: "test-workspace",
+          ownerName: "testuser",
+          agentName: "main",
+        }
+      );
+
+      expect(result.message).toBe(
+        'Workspace "testuser/test-workspace" initialized.'
+      );
+      expect(mockClient.createWorkspace).toHaveBeenCalled();
+    });
+  });
+
+  describe("existing workspace - stopped/stopping state", () => {
+    test("starts stopped workspace", async () => {
+      using computeServer = createMockComputeServer();
+
+      let getWorkspaceCallCount = 0;
+      const mockClient = createMockCoderClient({
+        getWorkspace: mock(() => {
+          getWorkspaceCallCount++;
+          // First call returns stopped, subsequent calls return running
+          if (getWorkspaceCallCount === 1) {
+            return Promise.resolve(
+              mockCoderWorkspace({
+                latest_build: mockCoderWorkspaceBuild({ status: "stopped" }),
+              })
+            );
+          }
+          return Promise.resolve(mockCoderWorkspace());
+        }),
+        getAppHost: mock(() =>
+          Promise.resolve(`localhost:${computeServer.port}`)
+        ),
+      });
+
+      const result = await initializeCoderWorkspace(
+        noopLogger,
+        { ...baseCoderTestOptions, client: mockClient },
+        {
+          workspaceId: "ws-123",
+          workspaceName: "test-workspace",
+          ownerName: "testuser",
+          agentName: "main",
+        }
+      );
+
+      expect(result.message).toBe(
+        'Workspace "testuser/test-workspace" started and initialized.'
+      );
+      expect(mockClient.createWorkspaceBuild).toHaveBeenCalledWith("ws-123", {
+        transition: "start",
+      });
+    });
+
+    test("starts stopping workspace", async () => {
+      using computeServer = createMockComputeServer();
+
+      let getWorkspaceCallCount = 0;
+      const mockClient = createMockCoderClient({
+        getWorkspace: mock(() => {
+          getWorkspaceCallCount++;
+          if (getWorkspaceCallCount === 1) {
+            return Promise.resolve(
+              mockCoderWorkspace({
+                latest_build: mockCoderWorkspaceBuild({ status: "stopping" }),
+              })
+            );
+          }
+          return Promise.resolve(mockCoderWorkspace());
+        }),
+        getAppHost: mock(() =>
+          Promise.resolve(`localhost:${computeServer.port}`)
+        ),
+      });
+
+      const result = await initializeCoderWorkspace(
+        noopLogger,
+        { ...baseCoderTestOptions, client: mockClient },
+        {
+          workspaceId: "ws-123",
+          workspaceName: "test-workspace",
+          ownerName: "testuser",
+          agentName: "main",
+        }
+      );
+
+      expect(result.message).toBe(
+        'Workspace "testuser/test-workspace" started and initialized.'
+      );
+      expect(mockClient.createWorkspaceBuild).toHaveBeenCalled();
+    });
+  });
+
+  describe("existing workspace - starting/pending state", () => {
+    test("waits for starting workspace", async () => {
+      using computeServer = createMockComputeServer();
+
+      let getWorkspaceCallCount = 0;
+      const mockClient = createMockCoderClient({
+        getWorkspace: mock(() => {
+          getWorkspaceCallCount++;
+          if (getWorkspaceCallCount === 1) {
+            return Promise.resolve(
+              mockCoderWorkspace({
+                latest_build: mockCoderWorkspaceBuild({ status: "starting" }),
+              })
+            );
+          }
+          return Promise.resolve(mockCoderWorkspace());
+        }),
+        getAppHost: mock(() =>
+          Promise.resolve(`localhost:${computeServer.port}`)
+        ),
+      });
+
+      const result = await initializeCoderWorkspace(
+        noopLogger,
+        { ...baseCoderTestOptions, client: mockClient },
+        {
+          workspaceId: "ws-123",
+          workspaceName: "test-workspace",
+          ownerName: "testuser",
+          agentName: "main",
+        }
+      );
+
+      expect(result.message).toBe(
+        'Workspace "testuser/test-workspace" initialized.'
+      );
+      expect(mockClient.createWorkspaceBuild).not.toHaveBeenCalled();
+    });
+
+    test("waits for pending workspace", async () => {
+      using computeServer = createMockComputeServer();
+
+      let getWorkspaceCallCount = 0;
+      const mockClient = createMockCoderClient({
+        getWorkspace: mock(() => {
+          getWorkspaceCallCount++;
+          if (getWorkspaceCallCount === 1) {
+            return Promise.resolve(
+              mockCoderWorkspace({
+                latest_build: mockCoderWorkspaceBuild({ status: "pending" }),
+              })
+            );
+          }
+          return Promise.resolve(mockCoderWorkspace());
+        }),
+        getAppHost: mock(() =>
+          Promise.resolve(`localhost:${computeServer.port}`)
+        ),
+      });
+
+      const result = await initializeCoderWorkspace(
+        noopLogger,
+        { ...baseCoderTestOptions, client: mockClient },
+        {
+          workspaceId: "ws-123",
+          workspaceName: "test-workspace",
+          ownerName: "testuser",
+          agentName: "main",
+        }
+      );
+
+      expect(result.message).toBe(
+        'Workspace "testuser/test-workspace" initialized.'
+      );
+      expect(mockClient.createWorkspaceBuild).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("existing workspace - terminal states (fall through to create new)", () => {
+    test.each([
+      "failed",
+      "canceled",
+      "canceling",
+      "deleted",
+      "deleting",
+    ] as const)("creates new workspace when existing is %s", async (status) => {
+      using computeServer = createMockComputeServer();
+
+      let getWorkspaceCallCount = 0;
+      const mockClient = createMockCoderClient({
+        getWorkspace: mock(() => {
+          getWorkspaceCallCount++;
+          // First call: existing workspace in terminal state
+          if (getWorkspaceCallCount === 1) {
+            return Promise.resolve(
+              mockCoderWorkspace({
+                latest_build: mockCoderWorkspaceBuild({ status }),
+              })
+            );
+          }
+          // Subsequent calls: newly created workspace is running
+          return Promise.resolve(mockCoderWorkspace({ id: "ws-new" }));
+        }),
+        createWorkspace: mock(() =>
+          Promise.resolve(mockCoderWorkspace({ id: "ws-new" }))
+        ),
+        getAppHost: mock(() =>
+          Promise.resolve(`localhost:${computeServer.port}`)
+        ),
+      });
+
+      const result = await initializeCoderWorkspace(
+        noopLogger,
+        {
+          ...baseCoderTestOptions,
+          template: "test-template",
+          client: mockClient,
+        },
+        {
+          workspaceId: "ws-123",
+          workspaceName: "test-workspace",
+          ownerName: "testuser",
+          agentName: "main",
+        }
+      );
+
+      expect(result.message).toBe(
+        'Workspace "testuser/test-workspace" initialized.'
+      );
+      expect(mockClient.createWorkspace).toHaveBeenCalled();
+    });
+  });
+
+  describe("existing workspace - error handling", () => {
+    test("creates new workspace when getWorkspace throws", async () => {
+      using computeServer = createMockComputeServer();
+
+      const warnLogs: unknown[] = [];
+      const logger = {
+        ...noopLogger,
+        warn: (...args: unknown[]) => warnLogs.push(args),
+      };
+
+      let getWorkspaceCallCount = 0;
+      const mockClient = createMockCoderClient({
+        getWorkspace: mock(() => {
+          getWorkspaceCallCount++;
+          // First call: throws error (existing workspace check fails)
+          if (getWorkspaceCallCount === 1) {
+            return Promise.reject(new Error("Workspace not found"));
+          }
+          // Subsequent calls: newly created workspace is running
+          return Promise.resolve(mockCoderWorkspace({ id: "ws-new" }));
+        }),
+        createWorkspace: mock(() =>
+          Promise.resolve(mockCoderWorkspace({ id: "ws-new" }))
+        ),
+        getAppHost: mock(() =>
+          Promise.resolve(`localhost:${computeServer.port}`)
+        ),
+      });
+
+      const result = await initializeCoderWorkspace(
+        logger,
+        {
+          ...baseCoderTestOptions,
+          template: "test-template",
+          client: mockClient,
+        },
+        {
+          workspaceId: "ws-123",
+          workspaceName: "test-workspace",
+          ownerName: "testuser",
+          agentName: "main",
+        }
+      );
+
+      expect(result.message).toBe(
+        'Workspace "testuser/test-workspace" initialized.'
+      );
+      expect(mockClient.createWorkspace).toHaveBeenCalled();
+      expect(warnLogs.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe("new workspace creation", () => {
+    test("creates new workspace when no existing workspace", async () => {
+      using computeServer = createMockComputeServer();
+
+      const mockClient = createMockCoderClient({
+        getAppHost: mock(() =>
+          Promise.resolve(`localhost:${computeServer.port}`)
+        ),
+      });
+
+      const result = await initializeCoderWorkspace(
+        noopLogger,
+        {
+          ...baseCoderTestOptions,
+          template: "test-template",
+          client: mockClient,
+        },
+        undefined
+      );
+
+      expect(result.message).toBe(
+        'Workspace "testuser/test-workspace" initialized.'
+      );
+      expect(mockClient.createWorkspace).toHaveBeenCalled();
+      expect(mockClient.getTemplateByName).toHaveBeenCalledWith(
+        "org-123",
+        "test-template"
+      );
+    });
+
+    test("throws error when template option is missing", async () => {
+      const mockClient = createMockCoderClient();
+
+      await expect(
+        initializeCoderWorkspace(
+          noopLogger,
+          { ...baseCoderTestOptions, client: mockClient },
+          undefined
+        )
+      ).rejects.toThrow("Template is required");
+    });
+
+    test("throws error when template not found", async () => {
+      const mockClient = createMockCoderClient({
+        getTemplateByName: mock(() => Promise.resolve(undefined)),
+      });
+
+      await expect(
+        initializeCoderWorkspace(
+          noopLogger,
+          {
+            ...baseCoderTestOptions,
+            template: "nonexistent-template",
+            client: mockClient,
+          },
+          undefined
+        )
+      ).rejects.toThrow("not found");
+    });
+
+    test("creates workspace with preset", async () => {
+      using computeServer = createMockComputeServer();
+
+      const mockClient = createMockCoderClient({
+        getTemplateVersionPresets: mock(() =>
+          Promise.resolve([
+            mockCoderPreset({ ID: "preset-abc", Name: "my-preset" }),
+            mockCoderPreset({ ID: "preset-def", Name: "other-preset" }),
+          ])
+        ),
+        getAppHost: mock(() =>
+          Promise.resolve(`localhost:${computeServer.port}`)
+        ),
+      });
+
+      await initializeCoderWorkspace(
+        noopLogger,
+        {
+          ...baseCoderTestOptions,
+          template: "test-template",
+          presetName: "my-preset",
+          client: mockClient,
+        },
+        undefined
+      );
+
+      expect(mockClient.createWorkspace).toHaveBeenCalledWith(
+        "org-123",
+        expect.objectContaining({
+          template_version_preset_id: "preset-abc",
+        })
+      );
+    });
+
+    test("throws error when preset not found", async () => {
+      const mockClient = createMockCoderClient({
+        getTemplateVersionPresets: mock(() =>
+          Promise.resolve([mockCoderPreset({ Name: "other-preset" })])
+        ),
+      });
+
+      await expect(
+        initializeCoderWorkspace(
+          noopLogger,
+          {
+            ...baseCoderTestOptions,
+            template: "test-template",
+            presetName: "nonexistent-preset",
+            client: mockClient,
+          },
+          undefined
+        )
+      ).rejects.toThrow("Preset 'nonexistent-preset' not found");
+    });
+
+    test("passes rich parameters to createWorkspace", async () => {
+      using computeServer = createMockComputeServer();
+
+      const mockClient = createMockCoderClient({
+        getAppHost: mock(() =>
+          Promise.resolve(`localhost:${computeServer.port}`)
+        ),
+      });
+
+      await initializeCoderWorkspace(
+        noopLogger,
+        {
+          ...baseCoderTestOptions,
+          template: "test-template",
+          richParameters: [
+            { name: "cpu", value: "4" },
+            { name: "memory", value: "8GB" },
+          ],
+          client: mockClient,
+        },
+        undefined
+      );
+
+      expect(mockClient.createWorkspace).toHaveBeenCalledWith(
+        "org-123",
+        expect.objectContaining({
+          rich_parameter_values: [
+            { name: "cpu", value: "4" },
+            { name: "memory", value: "8GB" },
+          ],
+        })
+      );
+    });
+  });
+});
+
+describe("getCoderWorkspaceClient", () => {
+  test("throws when workspace not running", async () => {
+    const mockClient = createMockCoderClient({
+      getWorkspace: mock(() =>
+        Promise.resolve(
+          mockCoderWorkspace({
+            latest_build: mockCoderWorkspaceBuild({ status: "stopped" }),
+          })
+        )
+      ),
+    });
+
+    await expect(
+      getCoderWorkspaceClient(
+        { ...baseCoderTestOptions, client: mockClient },
+        {
+          workspaceId: "ws-123",
+          workspaceName: "test-workspace",
+          ownerName: "testuser",
+          agentName: "main",
+        }
+      )
+    ).rejects.toThrow("not running");
+  });
+
+  test("throws when agent not found", async () => {
+    const mockClient = createMockCoderClient({
+      getWorkspace: mock(() =>
+        Promise.resolve(
+          mockCoderWorkspace({
+            latest_build: mockCoderWorkspaceBuild({
+              resources: [
+                {
+                  id: "res-123",
+                  name: "main",
+                  type: "docker_container",
+                  agents: [
+                    {
+                      id: "agent-other",
+                      name: "other-agent",
+                      status: "connected",
+                    },
+                  ],
+                },
+              ],
+            }),
+          })
+        )
+      ),
+    });
+
+    await expect(
+      getCoderWorkspaceClient(
+        { ...baseCoderTestOptions, client: mockClient },
+        {
+          workspaceId: "ws-123",
+          workspaceName: "test-workspace",
+          ownerName: "testuser",
+          agentName: "nonexistent-agent",
+        }
+      )
+    ).rejects.toThrow("Agent not found");
+  });
+
+  test("throws when agent not connected", async () => {
+    const mockClient = createMockCoderClient({
+      getWorkspace: mock(() =>
+        Promise.resolve(
+          mockCoderWorkspace({
+            latest_build: mockCoderWorkspaceBuild({
+              resources: [
+                {
+                  id: "res-123",
+                  name: "main",
+                  type: "docker_container",
+                  agents: [
+                    {
+                      id: "agent-123",
+                      name: "main",
+                      status: "disconnected",
+                    },
+                  ],
+                },
+              ],
+            }),
+          })
+        )
+      ),
+    });
+
+    await expect(
+      getCoderWorkspaceClient(
+        { ...baseCoderTestOptions, client: mockClient },
+        {
+          workspaceId: "ws-123",
+          workspaceName: "test-workspace",
+          ownerName: "testuser",
+          agentName: "main",
+        }
+      )
+    ).rejects.toThrow("not connected");
+  });
+
+  test("connects to running workspace via WebSocket", async () => {
+    using wsServer = createMockComputeServer();
+
+    const mockClient = createMockCoderClient({
+      getAppHost: mock(() => Promise.resolve(`localhost:${wsServer.port}`)),
+    });
+
+    const client = await getCoderWorkspaceClient(
+      {
+        ...baseCoderTestOptions,
+        client: mockClient,
+      },
+      {
+        workspaceId: "ws-123",
+        workspaceName: "test-workspace",
+        ownerName: "testuser",
+        agentName: "main",
+      }
+    );
+
+    expect(client).toBeDefined();
+  });
+
+  test("sends auth headers in WebSocket connection", async () => {
+    using wsServer = createMockComputeServer();
+
+    const mockClient = createMockCoderClient({
+      getAppHost: mock(() => Promise.resolve(`localhost:${wsServer.port}`)),
+    });
+
+    await getCoderWorkspaceClient(
+      {
+        coderUrl: "http://coder.example.com",
+        sessionToken: "my-secret-token",
+        computeServerPort: 22137,
+        client: mockClient,
+      },
+      {
+        workspaceId: "ws-123",
+        workspaceName: "test-workspace",
+        ownerName: "testuser",
+        agentName: "main",
+      }
+    );
+
+    const headers = wsServer.getReceivedHeaders();
+    expect(headers["coder-session-token"]).toBe("my-secret-token");
+    expect(headers.cookie).toContain("coder_session_token=my-secret-token");
+  });
+});
diff --git a/packages/scout-agent/lib/compute/coder/index.ts b/packages/scout-agent/lib/compute/coder/index.ts
new file mode 100644
index 0000000..3386ffa
--- /dev/null
+++ b/packages/scout-agent/lib/compute/coder/index.ts
@@ -0,0 +1,880 @@
+import type { Client } from "@blink-sdk/compute-protocol/client";
+import { WebSocket } from "ws";
+import { z } from "zod";
+import type { Logger } from "../../types";
+import { newComputeClient } from "../common";
+
+const WorkspaceStatusSchema = z.enum([
+  "pending",
+  "starting",
+  "running",
+  "stopping",
+  "stopped",
+  "failed",
+  "canceling",
+  "canceled",
+  "deleting",
+  "deleted",
+]);
+
+const AgentStatusSchema = z.enum([
+  "connecting",
+  "connected",
+  "disconnected",
+  "timeout",
+]);
+
+const WorkspaceAgentSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  status: AgentStatusSchema,
+});
+
+const WorkspaceResourceSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  type: z.string(),
+  agents: z.array(WorkspaceAgentSchema).optional(),
+});
+
+const WorkspaceBuildSchema = z.object({
+  id: z.string(),
+  status: WorkspaceStatusSchema,
+  resources: z.array(WorkspaceResourceSchema),
+});
+
+const WorkspaceSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  owner_name: z.string(),
+  template_id: z.string(),
+  template_name: z.string(),
+  latest_build: WorkspaceBuildSchema,
+});
+
+const TemplateSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  organization_id: z.string(),
+  active_version_id: z.string(),
+});
+
+const PresetSchema = z.object({
+  ID: z.string(),
+  Name: z.string(),
+  Default: z.boolean(),
+  Description: z.string().optional(),
+  Icon: z.string().optional(),
+});
+
+const UserSchema = z.object({
+  id: z.string(),
+  username: z.string(),
+});
+
+const OrganizationSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+});
+
+const AppHostSchema = z.object({
+  host: z.string(),
+});
+
+const CoderApiErrorSchema = z.object({
+  message: z.string(),
+  detail: z.string().optional(),
+});
+
+// The types below are not inferred from the schemas above due to typescript's isolatedDeclarations feature.
+
+type WorkspaceStatus =
+  | "pending"
+  | "starting"
+  | "running"
+  | "stopping"
+  | "stopped"
+  | "failed"
+  | "canceling"
+  | "canceled"
+  | "deleting"
+  | "deleted";
+
+type WorkspaceTransition = "start" | "stop" | "delete";
+
+type AgentStatus = "connecting" | "connected" | "disconnected" | "timeout";
+
+interface WorkspaceAgent {
+  id: string;
+  name: string;
+  status: AgentStatus;
+}
+
+interface WorkspaceResource {
+  id: string;
+  name: string;
+  type: string;
+  agents?: WorkspaceAgent[];
+}
+
+interface WorkspaceBuild {
+  id: string;
+  status: WorkspaceStatus;
+  resources: WorkspaceResource[];
+}
+
+interface Workspace {
+  id: string;
+  name: string;
+  owner_name: string;
+  template_id: string;
+  template_name: string;
+  latest_build: WorkspaceBuild;
+}
+
+interface Template {
+  id: string;
+  name: string;
+  organization_id: string;
+  active_version_id: string;
+}
+
+interface Preset {
+  ID: string;
+  Name: string;
+  Default: boolean;
+  Description?: string;
+  Icon?: string;
+}
+
+interface User {
+  id: string;
+  username: string;
+}
+
+interface Organization {
+  id: string;
+  name: string;
+}
+
+// Request types (not validated, these are what we send)
+interface WorkspaceBuildParameter {
+  name: string;
+  value: string;
+}
+
+interface CreateWorkspaceRequest {
+  template_id?: string;
+  template_version_id?: string;
+  name: string;
+  rich_parameter_values?: WorkspaceBuildParameter[];
+  template_version_preset_id?: string;
+}
+
+interface CreateWorkspaceBuildRequest {
+  transition: WorkspaceTransition;
+  rich_parameter_values?: WorkspaceBuildParameter[];
+}
+
+export class CoderApiClient {
+  private readonly baseUrl: string;
+  readonly sessionToken: string;
+
+  constructor(baseUrl: string, sessionToken: string) {
+    // Remove trailing slash if present
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.sessionToken = sessionToken;
+  }
+
+  private async request<T>(
+    method: string,
+    path: string,
+    schema: z.ZodType<T>,
+    body?: unknown
+  ): Promise<T> {
+    const url = `${this.baseUrl}${path}`;
+    const headers: Record<string, string> = {
+      "Coder-Session-Token": this.sessionToken,
+      Accept: "application/json",
+    };
+
+    if (body) {
+      headers["Content-Type"] = "application/json";
+    }
+
+    const response = await fetch(url, {
+      method,
+      headers,
+      body: body ? JSON.stringify(body) : undefined,
+    });
+
+    if (!response.ok) {
+      let errorMessage = `HTTP ${response.status}: ${response.statusText}`;
+      try {
+        const errorBody = CoderApiErrorSchema.safeParse(await response.json());
+        if (errorBody.success) {
+          errorMessage = errorBody.data.message || errorMessage;
+          if (errorBody.data.detail) {
+            errorMessage += ` - ${errorBody.data.detail}`;
+          }
+        }
+      } catch {
+        // Ignore JSON parse errors, use default message
+      }
+      throw new Error(errorMessage);
+    }
+
+    // Handle empty responses (204 No Content, etc.)
+    const contentType = response.headers.get("content-type");
+    if (response.status === 204 || !contentType?.includes("application/json")) {
+      return schema.parse({});
+    }
+
+    const json = await response.json();
+    return schema.parse(json);
+  }
+
+  // Get current authenticated user
+  async getMe(): Promise<User> {
+    return this.request("GET", "/api/v2/users/me", UserSchema);
+  }
+
+  // Get workspace by owner and name
+  async getWorkspaceByOwnerAndName(
+    owner: string,
+    name: string
+  ): Promise<Workspace | undefined> {
+    try {
+      return await this.request(
+        "GET",
+        `/api/v2/users/${encodeURIComponent(owner)}/workspace/${encodeURIComponent(name)}`,
+        WorkspaceSchema
+      );
+    } catch (err) {
+      if (err instanceof Error && err.message.includes("404")) {
+        return undefined;
+      }
+      throw err;
+    }
+  }
+
+  // Get workspace by ID
+  async getWorkspace(workspaceId: string): Promise<Workspace> {
+    return this.request(
+      "GET",
+      `/api/v2/workspaces/${encodeURIComponent(workspaceId)}`,
+      WorkspaceSchema
+    );
+  }
+
+  // Get template by name in organization
+  async getTemplateByName(
+    organizationId: string,
+    templateName: string
+  ): Promise<Template | undefined> {
+    try {
+      return await this.request(
+        "GET",
+        `/api/v2/organizations/${encodeURIComponent(organizationId)}/templates/${encodeURIComponent(templateName)}`,
+        TemplateSchema
+      );
+    } catch (err) {
+      if (err instanceof Error && err.message.includes("404")) {
+        return undefined;
+      }
+      throw err;
+    }
+  }
+
+  // Get default organization
+  async getDefaultOrganization(): Promise<Organization> {
+    return this.request(
+      "GET",
+      "/api/v2/organizations/default",
+      OrganizationSchema
+    );
+  }
+
+  // Create workspace in organization
+  async createWorkspace(
+    organizationId: string,
+    request: CreateWorkspaceRequest
+  ): Promise<Workspace> {
+    return this.request(
+      "POST",
+      `/api/v2/organizations/${encodeURIComponent(organizationId)}/members/me/workspaces`,
+      WorkspaceSchema,
+      request
+    );
+  }
+
+  // Create a new workspace build (start/stop/delete)
+  async createWorkspaceBuild(
+    workspaceId: string,
+    request: CreateWorkspaceBuildRequest
+  ): Promise<WorkspaceBuild> {
+    return this.request(
+      "POST",
+      `/api/v2/workspaces/${encodeURIComponent(workspaceId)}/builds`,
+      WorkspaceBuildSchema,
+      request
+    );
+  }
+
+  // Get the wildcard hostname for workspace applications
+  async getAppHost(): Promise<string> {
+    const response = await this.request(
+      "GET",
+      "/api/v2/applications/host",
+      AppHostSchema
+    );
+    // The response is an empty string if no wildcard access URL is configured
+    // https://github.com/coder/coder/blob/5d66aa95376d9df46371e2cbb3d6beaf1a0666cf/coderd/workspaceapps.go#L34
+    // https://github.com/coder/coder/blob/5d66aa95376d9df46371e2cbb3d6beaf1a0666cf/coderd/workspaceapps/appurl/appurl.go#L42
+    if (response.host === "") {
+      throw new Error(
+        "Coder deployment does not have a wildcard access URL configured. This is required for workspace support. See https://coder.com/docs/admin/networking/wildcard-access-url for configuration instructions."
+      );
+    }
+    return response.host;
+  }
+
+  // Get presets for a template version
+  async getTemplateVersionPresets(
+    templateVersionId: string
+  ): Promise<Preset[]> {
+    return this.request(
+      "GET",
+      `/api/v2/templateversions/${encodeURIComponent(templateVersionId)}/presets`,
+      z.array(PresetSchema)
+    );
+  }
+}
+
+export interface CoderWorkspaceInfo {
+  /** Workspace ID (UUID) */
+  workspaceId: string;
+  /** Workspace name */
+  workspaceName: string;
+  /** Owner username */
+  ownerName: string;
+  /** Agent ID to connect to */
+  agentId?: string;
+  /** Agent name */
+  agentName: string;
+}
+
+export interface InitializeCoderWorkspaceOptions {
+  /** Coder deployment URL (e.g., https://coder.example.com) */
+  coderUrl: string;
+  /** Session token for authentication */
+  sessionToken: string;
+  /** Port the blink compute server will listen on inside the workspace (default: 22137) */
+  computeServerPort?: number;
+  /** Optional CoderApiClient instance (for testing) */
+  client?: CoderApiClient;
+  /**
+   * Template name to create workspace from.
+   * Required if creating a new workspace.
+   */
+  template?: string;
+  /**
+   * Workspace name to use. If not provided and no existing workspace,
+   * a unique name will be generated.
+   */
+  workspaceName?: string;
+  /**
+   * Agent name to connect to. If workspace has multiple agents, this specifies which one.
+   * If not provided, uses the first available agent.
+   */
+  agentName?: string;
+  /**
+   * Rich template parameters for workspace creation.
+   */
+  richParameters?: Array<{ name: string; value: string }>;
+  /**
+   * Preset name for workspace creation. The preset must exist on the template version.
+   * Presets provide pre-configured parameter values.
+   */
+  presetName?: string;
+  /**
+   * Time to wait for workspace to start (in seconds). Default is 300 (5 minutes).
+   */
+  startTimeoutSeconds?: number;
+  /**
+   * Polling interval for workspace status checks in ms (default: 2000).
+   * Useful for testing.
+   */
+  pollingIntervalMs?: number;
+  /**
+   * Polling interval for compute server reachability checks in ms (default: 3000).
+   * Useful for testing.
+   */
+  computeServerPollingIntervalMs?: number;
+}
+
+const COMPUTE_SERVER_PORT = 22137;
+
+/**
+ * Extracts agents from workspace resources.
+ */
+function getAgentsFromWorkspace(workspace: Workspace): WorkspaceAgent[] {
+  const agents: WorkspaceAgent[] = [];
+  for (const resource of workspace.latest_build.resources || []) {
+    for (const agent of resource.agents || []) {
+      agents.push(agent);
+    }
+  }
+  return agents;
+}
+
+interface WaitForWorkspaceReadyOptions {
+  client: CoderApiClient;
+  workspaceId: string;
+  agentName: string | undefined;
+  timeoutSeconds: number;
+  computeServerPort: number;
+  /** Polling interval in ms (default: 2000) */
+  pollingIntervalMs?: number;
+  /** Compute server polling interval in ms (default: 3000) */
+  computeServerPollingIntervalMs?: number;
+  /** Use http:// instead of https:// (for local development) */
+  useHttp?: boolean;
+}
+
+/**
+ * Waits for workspace to be running and agent to be connected.
+ */
+async function waitForWorkspaceReady(
+  opts: WaitForWorkspaceReadyOptions
+): Promise<{ workspace: Workspace; agent: WorkspaceAgent }> {
+  const { client, workspaceId, agentName, timeoutSeconds } = opts;
+  const pollingIntervalMs = opts.pollingIntervalMs ?? 2000;
+  const computeServerPollingIntervalMs =
+    opts.computeServerPollingIntervalMs ?? 3000;
+  const startTime = Date.now();
+  const timeoutMs = timeoutSeconds * 1000;
+  const appHostname = await client.getAppHost();
+
+  while (Date.now() - startTime < timeoutMs) {
+    const workspace = await client.getWorkspace(workspaceId);
+    const status = workspace.latest_build.status;
+
+    if (status === "failed" || status === "canceled" || status === "deleted") {
+      throw new Error(
+        `Workspace ${workspace.name} is in terminal state: ${status}`
+      );
+    }
+
+    if (status === "running") {
+      const agents = getAgentsFromWorkspace(workspace);
+      if (agents.length === 0) {
+        await new Promise((resolve) => setTimeout(resolve, pollingIntervalMs));
+        continue;
+      }
+
+      // Find the requested agent or use the first one
+      const agent = agentName
+        ? agents.find((a) => a.name === agentName)
+        : agents[0];
+
+      if (!agent) {
+        throw new Error(
+          `Agent '${agentName}' not found. Available agents: ${agents.map((a) => a.name).join(", ")}`
+        );
+      }
+
+      if (agent.status === "connected") {
+        await ensureComputeServer({
+          agentName: agent.name,
+          workspaceName: workspace.name,
+          ownerName: workspace.owner_name,
+          computeServerPort: opts.computeServerPort,
+          appHostname: appHostname,
+          sessionToken: client.sessionToken,
+          pollingIntervalMs: computeServerPollingIntervalMs,
+          useHttp: opts.useHttp,
+        });
+        return { workspace, agent };
+      }
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, pollingIntervalMs));
+  }
+
+  throw new Error(
+    `Timeout waiting for workspace to be ready after ${timeoutSeconds} seconds`
+  );
+}
+
+interface ComputeServerConnectionInfo {
+  appHostname: string;
+  workspaceName: string;
+  ownerName: string;
+  agentName: string;
+  computeServerPort: number;
+  sessionToken: string;
+  /** Use http:// instead of https:// (for local development) */
+  useHttp?: boolean;
+}
+
+/**
+ * Checks if the compute server is reachable via the subdomain proxy.
+ */
+async function isComputeServerReachable(
+  opts: ComputeServerConnectionInfo
+): Promise<boolean> {
+  const {
+    appHostname,
+    workspaceName,
+    ownerName,
+    agentName,
+    computeServerPort,
+    sessionToken,
+    useHttp,
+  } = opts;
+  const appSubdomain = `${computeServerPort}--${agentName}--${workspaceName}--${ownerName}`;
+  const appHost = appHostname.replace("*", appSubdomain);
+  const protocol = useHttp ? "http" : "https";
+  const proxyUrl = `${protocol}://${appHost}/`;
+
+  try {
+    const response = await fetch(proxyUrl, {
+      method: "GET",
+      headers: {
+        "Coder-Session-Token": sessionToken,
+      },
+      signal: AbortSignal.timeout(5000),
+    });
+    // Any response (even error) from the compute server means it's running
+    // The proxy returns 502/503 if the backend is not reachable
+    return response.status !== 502 && response.status !== 503;
+  } catch {
+    return false;
+  }
+}
+
+interface EnsureComputeServerOptions {
+  agentName: string;
+  workspaceName: string;
+  ownerName: string;
+  computeServerPort: number;
+  appHostname: string;
+  sessionToken: string;
+  /** Polling interval in ms (default: 3000) */
+  pollingIntervalMs?: number;
+  /** Use http:// instead of https:// (for local development) */
+  useHttp?: boolean;
+}
+
+/**
+ * Ensures the blink compute server is running in the workspace.
+ * Polls the subdomain proxy until the compute server responds.
+ */
+async function ensureComputeServer(
+  opts: EnsureComputeServerOptions
+): Promise<void> {
+  const pollingIntervalMs = opts.pollingIntervalMs ?? 3000;
+  const connectionInfo: ComputeServerConnectionInfo = {
+    appHostname: opts.appHostname,
+    workspaceName: opts.workspaceName,
+    ownerName: opts.ownerName,
+    agentName: opts.agentName,
+    computeServerPort: opts.computeServerPort,
+    sessionToken: opts.sessionToken,
+    useHttp: opts.useHttp,
+  };
+
+  // Poll the subdomain proxy until the compute server responds
+  const startTime = Date.now();
+  const timeout = 120000; // 2 minutes for install + start
+
+  while (Date.now() - startTime < timeout) {
+    await new Promise((resolve) => setTimeout(resolve, pollingIntervalMs));
+
+    if (await isComputeServerReachable(connectionInfo)) {
+      return;
+    }
+  }
+
+  throw new Error("Timeout waiting for blink compute server to start");
+}
+
+/**
+ * Initializes a Coder workspace for use with blink compute.
+ */
+export const initializeCoderWorkspace = async (
+  logger: Logger,
+  options: InitializeCoderWorkspaceOptions,
+  existingWorkspaceInfo: CoderWorkspaceInfo | undefined
+): Promise<{ workspaceInfo: CoderWorkspaceInfo; message: string }> => {
+  const client =
+    options.client ??
+    new CoderApiClient(options.coderUrl, options.sessionToken);
+  const computeServerPort = options.computeServerPort || COMPUTE_SERVER_PORT;
+  const timeoutSeconds = options.startTimeoutSeconds || 300;
+
+  // Get current user for owner name
+  const me = await client.getMe();
+  const appHostname = await client.getAppHost();
+
+  // Check if we have an existing workspace
+  if (existingWorkspaceInfo) {
+    try {
+      const workspace = await client.getWorkspace(
+        existingWorkspaceInfo.workspaceId
+      );
+      const status = workspace.latest_build.status;
+
+      if (status === "running") {
+        const agents = getAgentsFromWorkspace(workspace);
+        const agent = existingWorkspaceInfo.agentName
+          ? agents.find((a) => a.name === existingWorkspaceInfo.agentName)
+          : agents.find((a) => a.id === existingWorkspaceInfo.agentId) ||
+            agents[0];
+
+        if (agent?.status === "connected") {
+          // Ensure compute server is running
+          await ensureComputeServer({
+            agentName: agent.name,
+            workspaceName: workspace.name,
+            ownerName: workspace.owner_name,
+            computeServerPort,
+            appHostname,
+            sessionToken: options.sessionToken,
+            pollingIntervalMs: options.computeServerPollingIntervalMs,
+            useHttp: options.coderUrl.startsWith("http://"),
+          });
+
+          return {
+            workspaceInfo: {
+              workspaceId: workspace.id,
+              workspaceName: workspace.name,
+              ownerName: workspace.owner_name,
+              agentId: agent.id,
+              agentName: agent.name,
+            },
+            message: `Workspace "${workspace.owner_name}/${workspace.name}" already initialized and running.`,
+          };
+        }
+      }
+
+      if (status === "stopped" || status === "stopping") {
+        logger.info(`Starting stopped workspace ${workspace.name}...`);
+        await client.createWorkspaceBuild(workspace.id, {
+          transition: "start",
+        });
+
+        const { workspace: readyWorkspace, agent } =
+          await waitForWorkspaceReady({
+            client,
+            workspaceId: workspace.id,
+            agentName: existingWorkspaceInfo.agentName,
+            timeoutSeconds,
+            computeServerPort,
+            pollingIntervalMs: options.pollingIntervalMs,
+            computeServerPollingIntervalMs:
+              options.computeServerPollingIntervalMs,
+            useHttp: options.coderUrl.startsWith("http://"),
+          });
+
+        return {
+          workspaceInfo: {
+            workspaceId: readyWorkspace.id,
+            workspaceName: readyWorkspace.name,
+            ownerName: readyWorkspace.owner_name,
+            agentId: agent.id,
+            agentName: agent.name,
+          },
+          message: `Workspace "${readyWorkspace.owner_name}/${readyWorkspace.name}" started and initialized.`,
+        };
+      }
+
+      if (status === "starting" || status === "pending") {
+        const { workspace: readyWorkspace, agent } =
+          await waitForWorkspaceReady({
+            client,
+            workspaceId: workspace.id,
+            agentName: existingWorkspaceInfo.agentName,
+            timeoutSeconds,
+            computeServerPort,
+            pollingIntervalMs: options.pollingIntervalMs,
+            computeServerPollingIntervalMs:
+              options.computeServerPollingIntervalMs,
+            useHttp: options.coderUrl.startsWith("http://"),
+          });
+
+        return {
+          workspaceInfo: {
+            workspaceId: readyWorkspace.id,
+            workspaceName: readyWorkspace.name,
+            ownerName: readyWorkspace.owner_name,
+            agentId: agent.id,
+            agentName: agent.name,
+          },
+          message: `Workspace "${readyWorkspace.owner_name}/${readyWorkspace.name}" initialized.`,
+        };
+      }
+    } catch (err: unknown) {
+      logger.warn(
+        "Error checking existing Coder workspace, will create a new one instead.",
+        err
+      );
+    }
+  }
+
+  // Create a new workspace
+  if (!options.template) {
+    throw new Error(
+      "Template is required to create a new workspace. Please provide the 'template' option."
+    );
+  }
+
+  // Get default organization and template
+  const org = await client.getDefaultOrganization();
+  const template = await client.getTemplateByName(org.id, options.template);
+  if (!template) {
+    throw new Error(
+      `Template '${options.template}' not found in organization '${org.name}'`
+    );
+  }
+
+  // Look up preset if specified
+  let presetId: string | undefined;
+  if (options.presetName) {
+    const presets = await client.getTemplateVersionPresets(
+      template.active_version_id
+    );
+    const preset = presets.find((p) => p.Name === options.presetName);
+    if (!preset) {
+      const availablePresets = presets.map((p) => p.Name).join(", ");
+      throw new Error(
+        `Preset '${options.presetName}' not found. Available presets: ${availablePresets || "(none)"}`
+      );
+    }
+    presetId = preset.ID;
+  }
+
+  const workspaceName =
+    options.workspaceName || `blink-${Date.now().toString(36)}`;
+
+  const workspace = await client.createWorkspace(org.id, {
+    template_id: template.id,
+    name: workspaceName,
+    rich_parameter_values: options.richParameters,
+    template_version_preset_id: presetId,
+  });
+
+  const { workspace: readyWorkspace, agent } = await waitForWorkspaceReady({
+    client,
+    workspaceId: workspace.id,
+    agentName: options.agentName,
+    timeoutSeconds,
+    computeServerPort,
+    pollingIntervalMs: options.pollingIntervalMs,
+    computeServerPollingIntervalMs: options.computeServerPollingIntervalMs,
+    useHttp: options.coderUrl.startsWith("http://"),
+  });
+
+  return {
+    workspaceInfo: {
+      workspaceId: readyWorkspace.id,
+      workspaceName: readyWorkspace.name,
+      ownerName: me.username,
+      agentId: agent.id,
+      agentName: agent.name,
+    },
+    message: `Workspace "${me.username}/${readyWorkspace.name}" initialized.`,
+  };
+};
+
+export interface GetCoderWorkspaceClientOptions {
+  /** Coder deployment URL */
+  coderUrl: string;
+  /** Session token for authentication */
+  sessionToken: string;
+  /** Port the blink compute server is listening on (default: 22137) */
+  computeServerPort?: number;
+  /** Optional CoderApiClient instance (for testing) */
+  client?: CoderApiClient;
+}
+
+/**
+ * Creates a compute client connected to a Coder workspace.
+ * Uses WebSocket via the Coder app proxy to connect directly to the compute server port.
+ */
+export const getCoderWorkspaceClient = async (
+  options: GetCoderWorkspaceClientOptions,
+  workspaceInfo: CoderWorkspaceInfo
+): Promise<Client> => {
+  const computeServerPort = options.computeServerPort ?? COMPUTE_SERVER_PORT;
+  const client =
+    options.client ??
+    new CoderApiClient(options.coderUrl, options.sessionToken);
+
+  // Get app hostname for subdomain proxy
+  const appHostname = await client.getAppHost();
+  if (!appHostname) {
+    throw new Error(
+      "Coder deployment does not have a wildcard app hostname configured. " +
+        "This is required for workspace app access."
+    );
+  }
+
+  // Verify workspace exists and is running
+  const workspace = await client.getWorkspace(workspaceInfo.workspaceId);
+
+  if (workspace.latest_build.status !== "running") {
+    throw new Error(
+      `Workspace ${workspaceInfo.workspaceName} is not running (status: ${workspace.latest_build.status}). Start it first.`
+    );
+  }
+
+  // Get agent info
+  const agents = getAgentsFromWorkspace(workspace);
+  const agent =
+    agents.find((a) => a.id === workspaceInfo.agentId) ||
+    agents.find((a) => a.name === workspaceInfo.agentName);
+
+  if (!agent) {
+    throw new Error(
+      `Agent not found for workspace ${workspaceInfo.workspaceName}. Available agents: ${agents.map((a) => a.name).join(", ")}`
+    );
+  }
+
+  if (agent.status !== "connected") {
+    throw new Error(
+      `Agent '${agent.name}' is not connected (status: ${agent.status}). Wait for it to connect.`
+    );
+  }
+
+  // Connect via the Coder app proxy using subdomain format
+  // For ports, agent name is REQUIRED
+  const appSubdomain = `${computeServerPort}--${agent.name}--${workspaceInfo.workspaceName}--${workspaceInfo.ownerName}`;
+
+  // Replace the wildcard in appHostname with the subdomain
+  // e.g., "*.apps.coder.com" -> "22137--dev--main--hugo.apps.coder.com"
+  const appHost = appHostname.replace("*", appSubdomain);
+
+  // Use ws:// for http:// URLs (e.g., local development), wss:// otherwise
+  const wsProtocol = options.coderUrl.startsWith("http://") ? "ws" : "wss";
+  const proxyUrl = `${wsProtocol}://${appHost}/`;
+
+  try {
+    const ws = new WebSocket(proxyUrl, {
+      headers: {
+        // Coder supports multiple auth methods - using both for compatibility
+        "Coder-Session-Token": options.sessionToken,
+        Cookie: `coder_session_token=${options.sessionToken}`,
+      },
+    });
+
+    return newComputeClient(ws);
+  } catch (err) {
+    throw new Error(
+      `Failed to connect to compute server. ` +
+        `Make sure the blink compute server is running in the workspace. ` +
+        `Original error: ${err}`
+    );
+  }
+};
diff --git a/packages/scout-agent/lib/compute/test-utils.ts b/packages/scout-agent/lib/compute/test-utils.ts
new file mode 100644
index 0000000..780e2fb
--- /dev/null
+++ b/packages/scout-agent/lib/compute/test-utils.ts
@@ -0,0 +1,239 @@
+import { mock } from "bun:test";
+import * as http from "node:http";
+import { Server as ComputeServer } from "@blink-sdk/compute-protocol/server";
+import { WebSocketServer } from "ws";
+import type { CoderApiClient } from "./coder/index";
+import type { DaytonaClient, DaytonaSandbox } from "./daytona/index";
+
+export const noopLogger = {
+  info: () => {},
+  warn: () => {},
+  error: () => {},
+};
+
+// Fast polling intervals for tests
+export const TEST_POLLING_INTERVAL_MS = 10;
+export const TEST_COMPUTE_SERVER_POLLING_INTERVAL_MS = 10;
+
+// Base coder test options to avoid repetition
+export const baseCoderTestOptions = {
+  coderUrl: "http://coder.example.com",
+  sessionToken: "test-token",
+  computeServerPort: 22137,
+  pollingIntervalMs: TEST_POLLING_INTERVAL_MS,
+  computeServerPollingIntervalMs: TEST_COMPUTE_SERVER_POLLING_INTERVAL_MS,
+} as const;
+
+// ============================================================================
+// Mock Compute Server
+// ============================================================================
+
+/**
+ * Creates a mock compute server that handles both HTTP requests (for health checks)
+ * and WebSocket connections (for compute protocol).
+ */
+export const createMockComputeServer = () => {
+  // Create HTTP server that handles both regular requests and WebSocket upgrades
+  const httpServer = http.createServer((_req, res) => {
+    // Handle HTTP requests (e.g., health checks from coder's ensureComputeServer)
+    res.writeHead(200, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ status: "ok" }));
+  });
+
+  const wss = new WebSocketServer({ server: httpServer });
+  let receivedHeaders: Record<string, string> = {};
+
+  wss.on("connection", (ws, req) => {
+    receivedHeaders = req.headers as Record<string, string>;
+
+    // Create the compute protocol server that sends responses via WebSocket
+    const computeServer = new ComputeServer({
+      send: (message: Uint8Array) => {
+        ws.send(message);
+      },
+    });
+
+    // Forward WebSocket messages to the compute server
+    ws.on("message", (data: Buffer) => {
+      computeServer.handleMessage(new Uint8Array(data));
+    });
+  });
+
+  httpServer.listen(0);
+  const address = httpServer.address();
+  const port =
+    typeof address === "object" && address !== null ? address.port : 0;
+  const url = `ws://localhost:${port}`;
+
+  return {
+    url,
+    port,
+    getReceivedHeaders: () => receivedHeaders,
+    [Symbol.dispose]: () => {
+      wss.close();
+      httpServer.close();
+    },
+  };
+};
+
+// ============================================================================
+// Coder Mock Helpers
+// ============================================================================
+
+export const mockCoderWorkspaceBuild = (
+  overrides: {
+    status?:
+      | "pending"
+      | "starting"
+      | "running"
+      | "stopping"
+      | "stopped"
+      | "failed"
+      | "canceling"
+      | "canceled"
+      | "deleting"
+      | "deleted";
+    resources?: Array<{
+      id: string;
+      name: string;
+      type: string;
+      agents?: Array<{
+        id: string;
+        name: string;
+        status: "connecting" | "connected" | "disconnected" | "timeout";
+      }>;
+    }>;
+  } = {}
+) => ({
+  id: "build-123",
+  status: "running" as const,
+  resources: [
+    {
+      id: "res-123",
+      name: "main",
+      type: "docker_container",
+      agents: [
+        {
+          id: "agent-123",
+          name: "main",
+          status: "connected" as const,
+        },
+      ],
+    },
+  ],
+  ...overrides,
+});
+
+export const mockCoderWorkspace = (
+  overrides: {
+    id?: string;
+    name?: string;
+    owner_name?: string;
+    template_id?: string;
+    template_name?: string;
+    latest_build?: ReturnType<typeof mockCoderWorkspaceBuild>;
+  } = {}
+) => ({
+  id: "ws-123",
+  name: "test-workspace",
+  owner_name: "testuser",
+  template_id: "tmpl-123",
+  template_name: "test-template",
+  latest_build: mockCoderWorkspaceBuild(),
+  ...overrides,
+});
+
+export const mockCoderTemplate = (
+  overrides: {
+    id?: string;
+    name?: string;
+    organization_id?: string;
+    active_version_id?: string;
+  } = {}
+) => ({
+  id: "tmpl-123",
+  name: "test-template",
+  organization_id: "org-123",
+  active_version_id: "ver-123",
+  ...overrides,
+});
+
+export const mockCoderPreset = (
+  overrides: {
+    ID?: string;
+    Name?: string;
+    Default?: boolean;
+  } = {}
+) => ({
+  ID: "preset-123",
+  Name: "default-preset",
+  Default: true,
+  ...overrides,
+});
+
+export const createMockCoderClient = (
+  overrides: Partial<{
+    sessionToken: string;
+    getMe: () => Promise<{ id: string; username: string }>;
+    getWorkspace: () => Promise<ReturnType<typeof mockCoderWorkspace>>;
+    getWorkspaceByOwnerAndName: () => Promise<
+      ReturnType<typeof mockCoderWorkspace> | undefined
+    >;
+    getTemplateByName: () => Promise<
+      ReturnType<typeof mockCoderTemplate> | undefined
+    >;
+    getDefaultOrganization: () => Promise<{ id: string; name: string }>;
+    createWorkspace: () => Promise<ReturnType<typeof mockCoderWorkspace>>;
+    createWorkspaceBuild: () => Promise<
+      ReturnType<typeof mockCoderWorkspaceBuild>
+    >;
+    getAppHost: () => Promise<string>;
+    getTemplateVersionPresets: () => Promise<
+      Array<ReturnType<typeof mockCoderPreset>>
+    >;
+  }> = {}
+) =>
+  ({
+    sessionToken: "test-token",
+    getMe: mock(() =>
+      Promise.resolve({ id: "user-123", username: "testuser" })
+    ),
+    getWorkspace: mock(() => Promise.resolve(mockCoderWorkspace())),
+    getWorkspaceByOwnerAndName: mock(() =>
+      Promise.resolve(mockCoderWorkspace())
+    ),
+    getTemplateByName: mock(() => Promise.resolve(mockCoderTemplate())),
+    getDefaultOrganization: mock(() =>
+      Promise.resolve({ id: "org-123", name: "default" })
+    ),
+    createWorkspace: mock(() => Promise.resolve(mockCoderWorkspace())),
+    createWorkspaceBuild: mock(() =>
+      Promise.resolve(mockCoderWorkspaceBuild())
+    ),
+    getAppHost: mock(() => Promise.resolve("*.apps.coder.example.com")),
+    getTemplateVersionPresets: mock(() => Promise.resolve([])),
+    ...overrides,
+  }) as unknown as CoderApiClient;
+
+// ============================================================================
+// Daytona Mock Helpers
+// ============================================================================
+
+export const createMockDaytonaSandbox = (
+  overrides: Partial<DaytonaSandbox> = {}
+): DaytonaSandbox => ({
+  id: "test-workspace-id",
+  state: "started",
+  start: mock(() => Promise.resolve()),
+  getPreviewLink: mock(() =>
+    Promise.resolve({ url: "ws://localhost:9999", token: "test-token" })
+  ),
+  ...overrides,
+});
+
+export const createMockDaytonaSdk = (
+  sandbox: DaytonaSandbox = createMockDaytonaSandbox()
+): DaytonaClient => ({
+  get: mock(() => Promise.resolve(sandbox)),
+  create: mock(() => Promise.resolve(sandbox)),
+});
diff --git a/packages/scout-agent/lib/core.test.ts b/packages/scout-agent/lib/core.test.ts
index 1159b11..7f10136 100644
--- a/packages/scout-agent/lib/core.test.ts
+++ b/packages/scout-agent/lib/core.test.ts
@@ -1,5 +1,4 @@
 import { describe, expect, mock, test } from "bun:test";
-import { Server as ComputeServer } from "@blink-sdk/compute-protocol/server";
 import {
   readUIMessageStream,
   simulateReadableStream,
@@ -9,15 +8,17 @@ import {
 import { MockLanguageModelV2 } from "ai/test";
 import * as blink from "blink";
 import { Client } from "blink/client";
-import { WebSocketServer } from "ws";
 import { getWorkspaceInfoKey } from "./compute/common";
-import type { DaytonaClient, DaytonaSandbox } from "./compute/daytona/index";
-import { type Message, Scout } from "./index";
 import {
-  createMockBlinkApiServer,
+  createMockCoderClient,
+  createMockComputeServer,
+  createMockDaytonaSandbox,
+  createMockDaytonaSdk,
+  mockCoderWorkspace,
   noopLogger,
-  withBlinkApiUrl,
-} from "./test-helpers";
+} from "./compute/test-utils";
+import { type Message, Scout } from "./index";
+import { createMockBlinkApiServer, withBlinkApiUrl } from "./test-helpers";
 
 // Add async iterator support to ReadableStream for testing
 declare global {
@@ -463,55 +464,6 @@ test("respond in slack", async () => {
   );
 });
 
-// Daytona integration test helpers
-const createMockDaytonaSandbox = (
-  overrides: Partial<DaytonaSandbox> = {}
-): DaytonaSandbox => ({
-  id: "test-workspace-id",
-  state: "started",
-  start: mock(() => Promise.resolve()),
-  getPreviewLink: mock(() =>
-    Promise.resolve({ url: "ws://localhost:9999", token: "test-token" })
-  ),
-  ...overrides,
-});
-
-const createMockDaytonaSdk = (
-  sandbox: DaytonaSandbox = createMockDaytonaSandbox()
-): DaytonaClient => ({
-  get: mock(() => Promise.resolve(sandbox)),
-  create: mock(() => Promise.resolve(sandbox)),
-});
-
-const createMockComputeServer = () => {
-  const wss = new WebSocketServer({ port: 0 });
-  const address = wss.address();
-  const port =
-    typeof address === "object" && address !== null ? address.port : 0;
-  const url = `ws://localhost:${port}`;
-
-  wss.on("connection", (ws) => {
-    // Create the compute protocol server that sends responses via WebSocket
-    const computeServer = new ComputeServer({
-      send: (message: Uint8Array) => {
-        ws.send(message);
-      },
-    });
-
-    // Forward WebSocket messages to the compute server
-    ws.on("message", (data: Buffer) => {
-      computeServer.handleMessage(new Uint8Array(data));
-    });
-  });
-
-  return {
-    url,
-    [Symbol.dispose]: () => {
-      wss.close();
-    },
-  };
-};
-
 describe("daytona integration", () => {
   test("Scout creates compute tools for daytona config", async () => {
     const { promise: doStreamOptionsPromise, resolve } =
@@ -789,3 +741,210 @@ describe("daytona integration", () => {
     expect(mockGetGithubAppContext).toHaveBeenCalledTimes(1);
   });
 });
+
+describe("coder integration", () => {
+  test("Scout creates compute tools for coder config", async () => {
+    const { promise: doStreamOptionsPromise, resolve } =
+      newPromise<DoStreamOptions>();
+
+    const mockClient = createMockCoderClient();
+
+    await using setupResult = await setup({
+      core: {
+        logger: noopLogger,
+        compute: {
+          type: "coder",
+          options: {
+            url: "http://coder.example.com",
+            sessionToken: "test-session-token",
+            computeServerPort: 22137,
+            template: "test-template",
+            coderClient: mockClient,
+          },
+        },
+      },
+      model: newMockModel({
+        textResponse: "coder test",
+        onDoStream: (options) => {
+          resolve(options);
+        },
+      }),
+    });
+    const { client } = setupResult;
+
+    const stream = await sendUserMessage(client, "hello");
+    for await (const _message of stream) {
+      // consume the stream
+    }
+
+    const callOptions = await doStreamOptionsPromise;
+    expect(callOptions.tools).toBeDefined();
+    expect(
+      callOptions.tools?.find((tool) => tool.name === "initialize_workspace")
+    ).toBeDefined();
+  });
+
+  test("initialize_workspace tool triggers coder client", async () => {
+    using apiServer = createMockBlinkApiServer();
+    using computeServer = createMockComputeServer();
+    using _env = withBlinkApiUrl(apiServer.url);
+
+    const mockClient = createMockCoderClient({
+      getWorkspaceByOwnerAndName: mock(() => Promise.resolve(undefined)),
+      createWorkspace: mock(() =>
+        Promise.resolve(mockCoderWorkspace({ id: "new-coder-workspace" }))
+      ),
+      getWorkspace: mock(() =>
+        Promise.resolve(mockCoderWorkspace({ id: "new-coder-workspace" }))
+      ),
+      getAppHost: mock(() =>
+        Promise.resolve(`localhost:${computeServer.port}`)
+      ),
+    });
+
+    const agent = new blink.Agent<Message>();
+    const scout = new Scout({
+      agent,
+      logger: noopLogger,
+      compute: {
+        type: "coder",
+        options: {
+          url: "http://coder.example.com",
+          sessionToken: "test-session-token",
+          computeServerPort: 22137,
+          template: "test-template",
+          coderClient: mockClient,
+          pollingIntervalMs: 10,
+          computeServerPollingIntervalMs: 10,
+        },
+      },
+    });
+
+    const chatID = "test-chat-id" as blink.ID;
+    const params = await scout.buildStreamTextParams({
+      chatID,
+      messages: [],
+      model: newMockModel({ textResponse: "test" }),
+    });
+    const result = streamText(params);
+
+    // Access the tools from the result and call initialize_workspace directly
+    // biome-ignore lint/suspicious/noExplicitAny: accessing internal tools for testing
+    const tools = (result as any).tools as Record<
+      string,
+      // biome-ignore lint/suspicious/noExplicitAny: mock input
+      { execute: (input: any) => Promise<string> }
+    >;
+    const initTool = tools.initialize_workspace;
+    expect(initTool).toBeDefined();
+
+    // Execute the tool - withModelIntent wrapper expects { model_intent, properties }
+    // biome-ignore lint/style/noNonNullAssertion: we just checked it's defined
+    const toolResult = await initTool!.execute({
+      model_intent: "initializing workspace",
+      properties: {},
+    });
+
+    expect(toolResult).toBe('Workspace "testuser/test-workspace" initialized.');
+    expect(mockClient.createWorkspace).toHaveBeenCalledTimes(1);
+
+    // Verify workspace info was stored
+    const storedValue = apiServer.storage[getWorkspaceInfoKey(chatID)];
+    expect(storedValue).toBeDefined();
+    const storedInfo = JSON.parse(storedValue as string);
+    expect(storedInfo.workspaceId).toBe("new-coder-workspace");
+  });
+
+  test("compute tools use coder client to connect to workspace", async () => {
+    using apiServer = createMockBlinkApiServer();
+    using computeServer = createMockComputeServer();
+    using _env = withBlinkApiUrl(apiServer.url);
+
+    const mockClient = createMockCoderClient({
+      getWorkspaceByOwnerAndName: mock(() => Promise.resolve(undefined)),
+      createWorkspace: mock(() =>
+        Promise.resolve(mockCoderWorkspace({ id: "workspace-for-compute" }))
+      ),
+      getWorkspace: mock(() =>
+        Promise.resolve(mockCoderWorkspace({ id: "workspace-for-compute" }))
+      ),
+      getAppHost: mock(() =>
+        Promise.resolve(`localhost:${computeServer.port}`)
+      ),
+    });
+
+    const agent = new blink.Agent<Message>();
+    const scout = new Scout({
+      agent,
+      logger: noopLogger,
+      compute: {
+        type: "coder",
+        options: {
+          url: "http://coder.example.com",
+          sessionToken: "test-session-token",
+          computeServerPort: 2137,
+          template: "test-template",
+          coderClient: mockClient,
+          pollingIntervalMs: 10,
+          computeServerPollingIntervalMs: 10,
+        },
+      },
+    });
+
+    const params = await scout.buildStreamTextParams({
+      chatID: "test-chat-id" as blink.ID,
+      messages: [],
+      model: newMockModel({ textResponse: "test" }),
+    });
+    const result = streamText(params);
+
+    // biome-ignore lint/suspicious/noExplicitAny: accessing internal tools for testing
+    const tools = (result as any).tools as Record<
+      string,
+      // biome-ignore lint/suspicious/noExplicitAny: mock input
+      { execute: (input: any) => Promise<unknown> }
+    >;
+
+    // First, initialize the workspace
+    // biome-ignore lint/style/noNonNullAssertion: we know it exists
+    await tools.initialize_workspace!.execute({
+      model_intent: "initializing workspace",
+      properties: {},
+    });
+
+    expect(mockClient.createWorkspace).toHaveBeenCalledTimes(1);
+    // Note: getWorkspace is called during initialization for polling (waitForWorkspaceReady)
+    const callsAfterInit = (mockClient.getWorkspace as ReturnType<typeof mock>)
+      .mock.calls.length;
+
+    // Now call a compute tool that uses the workspace client
+    // This should trigger getCoderWorkspaceClient which calls getWorkspace()
+    const readDirTool = tools.read_directory;
+    expect(readDirTool).toBeDefined();
+
+    // Call the tool - the compute server will handle the request
+    // biome-ignore lint/suspicious/noExplicitAny: test result
+    // biome-ignore lint/style/noNonNullAssertion: we just checked it's defined
+    const readResult: any = await readDirTool!.execute({
+      model_intent: "reading directory",
+      properties: {
+        directory_path: "/tmp",
+      },
+    });
+
+    // Verify the compute server responded correctly
+    expect(readResult).toBeDefined();
+    expect(readResult.entries).toBeDefined();
+
+    // Verify that the coder client was used to get the workspace (one more call than during init)
+    expect(
+      (mockClient.getWorkspace as ReturnType<typeof mock>).mock.calls.length
+    ).toBe(callsAfterInit + 1);
+    expect(mockClient.getWorkspace).toHaveBeenCalledWith(
+      "workspace-for-compute"
+    );
+
+    // Verify getAppHost was called (may be called multiple times during init and client creation)
+    expect(mockClient.getAppHost).toHaveBeenCalled();
+  });
+});
diff --git a/packages/scout-agent/lib/core.ts b/packages/scout-agent/lib/core.ts
index e919535..9e334c7 100644
--- a/packages/scout-agent/lib/core.ts
+++ b/packages/scout-agent/lib/core.ts
@@ -6,6 +6,12 @@ import * as slack from "@blink-sdk/slack";
 import type { App } from "@slack/bolt";
 import { convertToModelMessages, type LanguageModel, type Tool } from "ai";
 import type * as blink from "blink";
+import {
+  type CoderApiClient,
+  type CoderWorkspaceInfo,
+  getCoderWorkspaceClient,
+  initializeCoderWorkspace,
+} from "./compute/coder/index";
 import {
   type DaytonaClient,
   type DaytonaWorkspaceInfo,
@@ -71,6 +77,53 @@ interface WebSearchConfig {
   exaApiKey: string;
 }
 
+export interface CoderConfig {
+  /** Coder deployment URL (e.g., https://coder.example.com) */
+  url: string;
+  /** Session token for authentication */
+  sessionToken: string;
+  /** Port the blink compute server will listen on inside the workspace. Default: 22137 */
+  computeServerPort?: number;
+  /**
+   * Template name to create workspace from.
+   * Required if creating a new workspace.
+   */
+  template?: string;
+  /**
+   * Workspace name to use. If not provided and no existing workspace,
+   * a unique name will be generated.
+   */
+  workspaceName?: string;
+  /**
+   * Owner of the workspace. Defaults to the authenticated user.
+   */
+  owner?: string;
+  /**
+   * Agent name to connect to. If workspace has multiple agents, this specifies which one.
+   * If not provided, uses the first available agent.
+   */
+  agentName?: string;
+  /**
+   * Preset name for workspace creation. The preset must exist on the template version.
+   * Presets provide pre-configured parameter values.
+   */
+  presetName?: string;
+  /**
+   * Rich template parameters for workspace creation.
+   */
+  richParameters?: Array<{ name: string; value: string }>;
+  /**
+   * Time to wait for workspace to start (in seconds). Default is 300 (5 minutes).
+   */
+  startTimeoutSeconds?: number;
+  /** Optional CoderApiClient instance for testing. If not provided, a real client is created. */
+  coderClient?: CoderApiClient;
+  /** Polling interval in milliseconds for workspace state. Default is 2000. */
+  pollingIntervalMs?: number;
+  /** Polling interval in milliseconds for compute server readiness. Default is 3000. */
+  computeServerPollingIntervalMs?: number;
+}
+
 export interface DaytonaConfig {
   apiKey: string;
   computeServerPort: number;
@@ -86,6 +139,7 @@ export interface DaytonaConfig {
 
 type ComputeConfig =
   | { type: "docker" }
+  | { type: "coder"; options: CoderConfig }
   | { type: "daytona"; options: DaytonaConfig };
 
 const loadConfig = <K extends readonly string[]>(
@@ -309,6 +363,45 @@ export class Scout {
         });
         break;
       }
+      case "coder": {
+        const opts = computeConfig.options;
+        const computeServerPort = opts.computeServerPort ?? 22137;
+        computeTools = createComputeTools<CoderWorkspaceInfo>({
+          agent: this.agent,
+          githubAppContext,
+          chatID,
+          initializeWorkspace: (info) =>
+            initializeCoderWorkspace(
+              this.logger,
+              {
+                coderUrl: opts.url,
+                sessionToken: opts.sessionToken,
+                computeServerPort,
+                template: opts.template,
+                workspaceName: opts.workspaceName,
+                presetName: opts.presetName,
+                richParameters: opts.richParameters,
+                startTimeoutSeconds: opts.startTimeoutSeconds,
+                client: opts.coderClient,
+                pollingIntervalMs: opts.pollingIntervalMs,
+                computeServerPollingIntervalMs:
+                  opts.computeServerPollingIntervalMs,
+              },
+              info
+            ),
+          createWorkspaceClient: (info) =>
+            getCoderWorkspaceClient(
+              {
+                coderUrl: opts.url,
+                sessionToken: opts.sessionToken,
+                computeServerPort,
+                client: opts.coderClient,
+              },
+              info
+            ),
+        });
+        break;
+      }
       case "daytona": {
         const opts = computeConfig.options;
         computeTools = createComputeTools<DaytonaWorkspaceInfo>({
diff --git a/packages/scout-agent/lib/index.ts b/packages/scout-agent/lib/index.ts
index d9cf583..2b6d5a5 100644
--- a/packages/scout-agent/lib/index.ts
+++ b/packages/scout-agent/lib/index.ts
@@ -1,3 +1,4 @@
+export type { CoderApiClient, CoderWorkspaceInfo } from "./compute/coder/index";
 export type { DaytonaClient, DaytonaSandbox } from "./compute/daytona/index";
 export * from "./core";
 export * from "./slack";
diff --git a/packages/scout-agent/package.json b/packages/scout-agent/package.json
index c93e3ab..d35a682 100644
--- a/packages/scout-agent/package.json
+++ b/packages/scout-agent/package.json
@@ -1,7 +1,7 @@
 {
   "name": "@blink-sdk/scout-agent",
   "description": "A general-purpose AI agent with GitHub, Slack, web search, and compute capabilities built on Blink SDK.",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "type": "module",
   "keywords": [
     "blink",