diff --git a/packages/extension/src/kernel-integration/handle-panel-message.test.ts b/packages/extension/src/kernel-integration/handle-panel-message.test.ts
index acd7a843a..c325749b3 100644
--- a/packages/extension/src/kernel-integration/handle-panel-message.test.ts
+++ b/packages/extension/src/kernel-integration/handle-panel-message.test.ts
@@ -1,5 +1,4 @@
 import '@ocap/test-utils/mock-endoify';
-import { define, literal, object } from '@metamask/superstruct';
 import type {
   Kernel,
   KernelCommand,
@@ -7,6 +6,7 @@ import type {
   VatConfig,
   KVStore,
 } from '@ocap/kernel';
+import { setupOcapKernelMock } from '@ocap/test-utils';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 
 import type { KernelControlCommand } from './messages.js';
@@ -19,25 +19,7 @@ vi.mock('@ocap/utils', () => ({
   }),
 }));
 
-let isVatConfigMock = true;
-let isVatIdMock = true;
-
-// Mock kernel validation functions
-// because vitest needs to extend Error stack and under SES it fails
-vi.mock('@ocap/kernel', () => ({
-  isKernelCommand: () => true,
-  isVatId: () => isVatIdMock,
-  isVatConfig: () => isVatConfigMock,
-  VatIdStruct: define<VatId>('VatId', () => isVatIdMock),
-  VatConfigStruct: define<VatConfig>('VatConfig', () => isVatConfigMock),
-  KernelSendVatCommandStruct: object({
-    id: literal('v0'),
-    payload: object({
-      method: literal('ping'),
-      params: literal(null),
-    }),
-  }),
-}));
+const { setMockBehavior, resetMocks } = setupOcapKernelMock();
 
 describe('handlePanelMessage', () => {
   let mockKernel: Kernel;
@@ -45,9 +27,8 @@ describe('handlePanelMessage', () => {
 
   beforeEach(() => {
     vi.resetModules();
+    resetMocks();
 
-    isVatConfigMock = true;
-    isVatIdMock = true;
     mockKVStore = {
       get: vi.fn(),
       getRequired: vi.fn(),
@@ -117,7 +98,7 @@ describe('handlePanelMessage', () => {
 
     it('should handle invalid vat configuration', async () => {
       const { handlePanelMessage } = await import('./handle-panel-message');
-      isVatConfigMock = false;
+      setMockBehavior({ isVatConfig: false });
 
       const message: KernelControlCommand = {
         id: 'test-2',
@@ -173,7 +154,7 @@ describe('handlePanelMessage', () => {
 
     it('should handle invalid vat ID for restartVat command', async () => {
       const { handlePanelMessage } = await import('./handle-panel-message');
-      isVatIdMock = false;
+      setMockBehavior({ isVatId: false });
 
       const message: KernelControlCommand = {
         id: 'test-4',
@@ -277,6 +258,7 @@ describe('handlePanelMessage', () => {
         payload: {
           method: 'getStatus',
           params: {
+            clusterConfig: undefined,
             vats: [
               {
                 id: 'v0',
diff --git a/packages/extension/src/kernel-integration/handlers/get-status.test.ts b/packages/extension/src/kernel-integration/handlers/get-status.test.ts
index 7b429874e..069bf8ba9 100644
--- a/packages/extension/src/kernel-integration/handlers/get-status.test.ts
+++ b/packages/extension/src/kernel-integration/handlers/get-status.test.ts
@@ -3,6 +3,7 @@ import type { Kernel, KVStore } from '@ocap/kernel';
 import { describe, it, expect, vi } from 'vitest';
 
 import { getStatusHandler } from './get-status.js';
+import clusterConfig from '../../vats/default-cluster.json';
 
 describe('getStatusHandler', () => {
   const mockVats = [
@@ -11,6 +12,7 @@ describe('getStatusHandler', () => {
   ];
 
   const mockKernel = {
+    clusterConfig,
     getVats: vi.fn(() => mockVats),
   } as unknown as Kernel;
 
@@ -24,13 +26,13 @@ describe('getStatusHandler', () => {
     expect(getStatusHandler.schema).toBeDefined();
   });
 
-  it('should return vats status', async () => {
+  it('should return vats status and cluster config', async () => {
     const result = await getStatusHandler.implementation(
       mockKernel,
       mockKVStore,
       null,
     );
     expect(mockKernel.getVats).toHaveBeenCalledOnce();
-    expect(result).toStrictEqual({ vats: mockVats });
+    expect(result).toStrictEqual({ vats: mockVats, clusterConfig });
   });
 });
diff --git a/packages/extension/src/kernel-integration/handlers/get-status.ts b/packages/extension/src/kernel-integration/handlers/get-status.ts
index b0f1e3a3f..f91e049a8 100644
--- a/packages/extension/src/kernel-integration/handlers/get-status.ts
+++ b/packages/extension/src/kernel-integration/handlers/get-status.ts
@@ -15,6 +15,7 @@ export const getStatusHandler: CommandHandler<GetStatusMethod> = {
   implementation: async (kernel: Kernel): Promise<Json> => {
     return {
       vats: kernel.getVats(),
-    };
+      clusterConfig: kernel.clusterConfig,
+    } as Json;
   },
 };
diff --git a/packages/extension/src/kernel-integration/handlers/index.ts b/packages/extension/src/kernel-integration/handlers/index.ts
index e6de62f2d..90cb6953b 100644
--- a/packages/extension/src/kernel-integration/handlers/index.ts
+++ b/packages/extension/src/kernel-integration/handlers/index.ts
@@ -7,6 +7,7 @@ import { restartVatHandler } from './restart-vat.js';
 import { sendVatCommandHandler } from './send-vat-command.js';
 import { terminateAllVatsHandler } from './terminate-all-vats.js';
 import { terminateVatHandler } from './terminate-vat.js';
+import { updateClusterConfigHandler } from './update-cluster-config.js';
 
 export const handlers = [
   getStatusHandler,
@@ -18,4 +19,5 @@ export const handlers = [
   restartVatHandler,
   terminateVatHandler,
   terminateAllVatsHandler,
+  updateClusterConfigHandler,
 ] as const;
diff --git a/packages/extension/src/kernel-integration/handlers/reload-config.test.ts b/packages/extension/src/kernel-integration/handlers/reload-config.test.ts
new file mode 100644
index 000000000..b6d91a1ee
--- /dev/null
+++ b/packages/extension/src/kernel-integration/handlers/reload-config.test.ts
@@ -0,0 +1,49 @@
+import '@ocap/test-utils/mock-endoify';
+import type { Kernel, KVStore } from '@ocap/kernel';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+import { reloadConfigHandler } from './reload-config.js';
+
+describe('reloadConfigHandler', () => {
+  const mockKernel = {
+    reload: vi.fn().mockResolvedValue(undefined),
+  } as Partial<Kernel>;
+
+  const mockKVStore = {} as KVStore;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should call kernel.reload() and return null', async () => {
+    const result = await reloadConfigHandler.implementation(
+      mockKernel as Kernel,
+      mockKVStore,
+      null,
+    );
+
+    expect(mockKernel.reload).toHaveBeenCalledTimes(1);
+    expect(result).toBeNull();
+  });
+
+  it('should use the correct method name', () => {
+    expect(reloadConfigHandler.method).toBe('reload');
+  });
+
+  it('should use the clearState schema for params', () => {
+    expect(reloadConfigHandler.schema).toBeDefined();
+  });
+
+  it('should propagate errors from kernel.reload()', async () => {
+    const error = new Error('Reload failed');
+    vi.mocked(mockKernel.reload)?.mockRejectedValueOnce(error);
+
+    await expect(
+      reloadConfigHandler.implementation(
+        mockKernel as Kernel,
+        mockKVStore,
+        null,
+      ),
+    ).rejects.toThrow(error);
+  });
+});
diff --git a/packages/extension/src/kernel-integration/handlers/reload-config.ts b/packages/extension/src/kernel-integration/handlers/reload-config.ts
index eaa1a8d2d..d7d3c3e32 100644
--- a/packages/extension/src/kernel-integration/handlers/reload-config.ts
+++ b/packages/extension/src/kernel-integration/handlers/reload-config.ts
@@ -13,7 +13,7 @@ export const reloadConfigHandler: CommandHandler<ReloadMethod> = {
   method: KernelControlMethod.reload,
   schema: KernelCommandPayloadStructs.clearState.schema.params,
   implementation: async (kernel: Kernel): Promise<Json> => {
-    await kernel.reset();
+    await kernel.reload();
     return null;
   },
 };
diff --git a/packages/extension/src/kernel-integration/handlers/send-vat-command.ts b/packages/extension/src/kernel-integration/handlers/send-vat-command.ts
index 3f8c5d40c..223aa43a0 100644
--- a/packages/extension/src/kernel-integration/handlers/send-vat-command.ts
+++ b/packages/extension/src/kernel-integration/handlers/send-vat-command.ts
@@ -1,6 +1,5 @@
-import { assert } from '@metamask/superstruct';
 import type { Json } from '@metamask/utils';
-import { isKernelCommand, KernelSendVatCommandStruct } from '@ocap/kernel';
+import { isKernelCommand } from '@ocap/kernel';
 import type { Kernel, KVStore } from '@ocap/kernel';
 
 import type { CommandHandler, CommandParams } from '../command-registry.js';
@@ -27,7 +26,6 @@ export const sendVatCommandHandler: CommandHandler<SendVatCommandMethod> = {
       throw new Error('Vat ID required for this command');
     }
 
-    assert(params, KernelSendVatCommandStruct);
     const result = await kernel.sendVatCommand(params.id, params.payload);
     return { result };
   },
diff --git a/packages/extension/src/kernel-integration/handlers/update-cluster-config.test.ts b/packages/extension/src/kernel-integration/handlers/update-cluster-config.test.ts
new file mode 100644
index 000000000..3c46adbdd
--- /dev/null
+++ b/packages/extension/src/kernel-integration/handlers/update-cluster-config.test.ts
@@ -0,0 +1,41 @@
+import '@ocap/test-utils/mock-endoify';
+import type { Kernel, KVStore } from '@ocap/kernel';
+import { describe, it, expect } from 'vitest';
+
+import { updateClusterConfigHandler } from './update-cluster-config.js';
+
+describe('updateClusterConfigHandler', () => {
+  const mockKernel = {
+    clusterConfig: null,
+  } as Partial<Kernel>;
+
+  const mockKvStore = {} as KVStore;
+
+  const testConfig = {
+    bootstrap: 'testVat',
+    vats: {
+      testVat: {
+        sourceSpec: 'test-source',
+      },
+    },
+  };
+
+  it('should update kernel cluster config', async () => {
+    const result = await updateClusterConfigHandler.implementation(
+      mockKernel as Kernel,
+      mockKvStore,
+      { config: testConfig },
+    );
+
+    expect(mockKernel.clusterConfig).toStrictEqual(testConfig);
+    expect(result).toBeNull();
+  });
+
+  it('should use the correct method name', () => {
+    expect(updateClusterConfigHandler.method).toBe('updateClusterConfig');
+  });
+
+  it('should validate the config using the correct schema', () => {
+    expect(updateClusterConfigHandler.schema).toBeDefined();
+  });
+});
diff --git a/packages/extension/src/kernel-integration/handlers/update-cluster-config.ts b/packages/extension/src/kernel-integration/handlers/update-cluster-config.ts
new file mode 100644
index 000000000..0ec016cb8
--- /dev/null
+++ b/packages/extension/src/kernel-integration/handlers/update-cluster-config.ts
@@ -0,0 +1,23 @@
+import type { Json } from '@metamask/utils';
+import type { ClusterConfig, Kernel, KVStore } from '@ocap/kernel';
+
+import type { CommandHandler } from '../command-registry.js';
+import {
+  KernelCommandPayloadStructs,
+  KernelControlMethod,
+} from '../messages.js';
+
+export const updateClusterConfigHandler: CommandHandler<
+  typeof KernelControlMethod.updateClusterConfig
+> = {
+  method: KernelControlMethod.updateClusterConfig,
+  schema: KernelCommandPayloadStructs.updateClusterConfig.schema.params,
+  implementation: async (
+    kernel: Kernel,
+    _kvStore: KVStore,
+    params: { config: ClusterConfig },
+  ): Promise<Json> => {
+    kernel.clusterConfig = params.config;
+    return null;
+  },
+};
diff --git a/packages/extension/src/kernel-integration/kernel-worker.ts b/packages/extension/src/kernel-integration/kernel-worker.ts
index 3779003e5..30eb9c8f6 100644
--- a/packages/extension/src/kernel-integration/kernel-worker.ts
+++ b/packages/extension/src/kernel-integration/kernel-worker.ts
@@ -1,46 +1,18 @@
 import type {
+  ClusterConfig,
   KernelCommand,
   KernelCommandReply,
-  ClusterConfig,
 } from '@ocap/kernel';
-import { isKernelCommand, Kernel } from '@ocap/kernel';
+import { ClusterConfigStruct, isKernelCommand, Kernel } from '@ocap/kernel';
 import type { PostMessageTarget } from '@ocap/streams';
 import { MessagePortDuplexStream, receiveMessagePort } from '@ocap/streams';
-import { makeLogger } from '@ocap/utils';
+import { fetchValidatedJson, makeLogger } from '@ocap/utils';
 
 import { handlePanelMessage } from './handle-panel-message.js';
 import { makeSQLKVStore } from './sqlite-kv-store.js';
 import { receiveUiConnections } from './ui-connections.js';
 import { ExtensionVatWorkerClient } from './VatWorkerClient.js';
 
-const bundleHost = 'http://localhost:3000'; // XXX placeholder
-const sampleBundle = 'sample-vat.bundle';
-const bundleURL = `${bundleHost}/${sampleBundle}`;
-
-const defaultSubcluster: ClusterConfig = {
-  bootstrap: 'alice',
-  vats: {
-    alice: {
-      bundleSpec: bundleURL,
-      parameters: {
-        name: 'Alice',
-      },
-    },
-    bob: {
-      bundleSpec: bundleURL,
-      parameters: {
-        name: 'Bob',
-      },
-    },
-    carol: {
-      bundleSpec: bundleURL,
-      parameters: {
-        name: 'Carol',
-      },
-    },
-  },
-};
-
 const logger = makeLogger('[kernel worker]');
 
 main().catch(logger.error);
@@ -65,13 +37,24 @@ async function main(): Promise<void> {
   );
   const kvStore = await makeSQLKVStore();
 
-  const kernel = new Kernel(kernelStream, vatWorkerClient, kvStore);
+  const kernel = new Kernel(kernelStream, vatWorkerClient, kvStore, {
+    // XXX Warning: Clearing storage here is a hack to aid development
+    // debugging, wherein extension reloads are almost exclusively used for
+    // retrying after tweaking some fix. The following line will prevent
+    // the accumulation of long term kernel state.
+    resetStorage: true,
+  });
   receiveUiConnections(
     async (message) => handlePanelMessage(kernel, kvStore, message),
     logger,
   );
   await kernel.init();
 
+  const defaultSubcluster = await fetchValidatedJson<ClusterConfig>(
+    new URL('../vats/default-cluster.json', import.meta.url).href,
+    ClusterConfigStruct,
+  );
+
   await Promise.all([
     vatWorkerClient.start(),
     // XXX We are mildly concerned that there's a small chance that a race here
diff --git a/packages/extension/src/kernel-integration/messages.test.ts b/packages/extension/src/kernel-integration/messages.test.ts
index b2b251f6d..40f138410 100644
--- a/packages/extension/src/kernel-integration/messages.test.ts
+++ b/packages/extension/src/kernel-integration/messages.test.ts
@@ -7,6 +7,7 @@ import {
   isKernelControlReply,
   isKernelStatus,
 } from './messages';
+import clusterConfig from '../vats/default-cluster.json';
 
 describe('KernelControlMethod', () => {
   it('should have all expected methods', () => {
@@ -20,6 +21,7 @@ describe('KernelControlMethod', () => {
       'sendVatCommand',
       'clearState',
       'executeDBQuery',
+      'updateClusterConfig',
     ]);
   });
 });
@@ -179,6 +181,7 @@ describe('isKernelControlReply', () => {
         payload: {
           method: KernelControlMethod.getStatus,
           params: {
+            clusterConfig,
             vats: [
               {
                 id: 'v0',
@@ -235,6 +238,7 @@ describe('isKernelStatus', () => {
     [
       'valid kernel status',
       {
+        clusterConfig,
         vats: [
           {
             id: 'v0',
@@ -244,14 +248,33 @@ describe('isKernelStatus', () => {
       },
       true,
     ],
-    ['empty vats array', { vats: [] }, true],
+    ['empty vats array', { vats: [], clusterConfig }, true],
     ['null value', null, false],
     ['undefined value', undefined, false],
     ['empty object', {}, false],
-    ['null vats', { vats: null }, false],
-    ['invalid vats type', { vats: 'invalid' }, false],
-    ['invalid vat object', { vats: [{ invalid: true }] }, false],
-    ['invalid vat id type', { vats: [{ id: 123, config: {} }] }, false],
+    ['null vats', { vats: null, clusterConfig }, false],
+    ['invalid vats type', { vats: 'invalid', clusterConfig }, false],
+    ['invalid vat object', { vats: [{ invalid: true }], clusterConfig }, false],
+    [
+      'invalid vat id type',
+      { vats: [{ id: 123, config: {} }], clusterConfig },
+      false,
+    ],
+    ['invalid cluster config', { vats: [], clusterConfig: 'invalid' }, false],
+    ['invalid cluster config type', { vats: [], clusterConfig: 123 }, false],
+    ['invalid cluster config object', { vats: [], clusterConfig: {} }, false],
+    ['invalid cluster config array', { vats: [], clusterConfig: [] }, false],
+    [
+      'invalid cluster config boolean',
+      { vats: [], clusterConfig: true },
+      false,
+    ],
+    ['invalid cluster config number', { vats: [], clusterConfig: 123 }, false],
+    [
+      'invalid cluster config string',
+      { vats: [], clusterConfig: 'test' },
+      false,
+    ],
   ])('should validate %s', (_, status, expected) => {
     expect(isKernelStatus(status)).toBe(expected);
   });
diff --git a/packages/extension/src/kernel-integration/messages.ts b/packages/extension/src/kernel-integration/messages.ts
index 99d24a518..acbc1e730 100644
--- a/packages/extension/src/kernel-integration/messages.ts
+++ b/packages/extension/src/kernel-integration/messages.ts
@@ -11,8 +11,11 @@ import {
 import type { Infer } from '@metamask/superstruct';
 import type { Json } from '@metamask/utils';
 import { UnsafeJsonStruct } from '@metamask/utils';
-import type { VatConfig, VatId } from '@ocap/kernel';
-import { VatConfigStruct, VatIdStruct } from '@ocap/kernel';
+import {
+  ClusterConfigStruct,
+  VatConfigStruct,
+  VatIdStruct,
+} from '@ocap/kernel';
 import type { TypeGuard } from '@ocap/utils';
 
 export const KernelControlMethod = {
@@ -25,18 +28,13 @@ export const KernelControlMethod = {
   sendVatCommand: 'sendVatCommand',
   clearState: 'clearState',
   executeDBQuery: 'executeDBQuery',
+  updateClusterConfig: 'updateClusterConfig',
 } as const;
 
 export type KernelMethods = keyof typeof KernelControlMethod;
 
-export type KernelStatus = {
-  vats: {
-    id: VatId;
-    config: VatConfig;
-  }[];
-};
-
 const KernelStatusStruct = type({
+  clusterConfig: ClusterConfigStruct,
   vats: array(
     object({
       id: VatIdStruct,
@@ -45,6 +43,8 @@ const KernelStatusStruct = type({
   ),
 });
 
+export type KernelStatus = Infer<typeof KernelStatusStruct>;
+
 // Command payload structs
 export const KernelCommandPayloadStructs = {
   [KernelControlMethod.launchVat]: object({
@@ -88,6 +88,12 @@ export const KernelCommandPayloadStructs = {
       sql: string(),
     }),
   }),
+  [KernelControlMethod.updateClusterConfig]: object({
+    method: literal(KernelControlMethod.updateClusterConfig),
+    params: object({
+      config: ClusterConfigStruct,
+    }),
+  }),
 } as const;
 
 export const KernelReplyPayloadStructs = {
@@ -130,6 +136,10 @@ export const KernelReplyPayloadStructs = {
       object({ error: string() }),
     ]),
   }),
+  [KernelControlMethod.updateClusterConfig]: object({
+    method: literal(KernelControlMethod.updateClusterConfig),
+    params: literal(null),
+  }),
 } as const;
 
 const KernelControlCommandStruct = object({
@@ -144,6 +154,7 @@ const KernelControlCommandStruct = object({
     KernelCommandPayloadStructs.sendVatCommand,
     KernelCommandPayloadStructs.clearState,
     KernelCommandPayloadStructs.executeDBQuery,
+    KernelCommandPayloadStructs.updateClusterConfig,
   ]),
 });
 
@@ -159,6 +170,7 @@ const KernelControlReplyStruct = object({
     KernelReplyPayloadStructs.sendVatCommand,
     KernelReplyPayloadStructs.clearState,
     KernelReplyPayloadStructs.executeDBQuery,
+    KernelReplyPayloadStructs.updateClusterConfig,
   ]),
 });
 
diff --git a/packages/extension/src/kernel-integration/ui-connections.test.ts b/packages/extension/src/kernel-integration/ui-connections.test.ts
index 4b408b3ab..fe9cc1420 100644
--- a/packages/extension/src/kernel-integration/ui-connections.test.ts
+++ b/packages/extension/src/kernel-integration/ui-connections.test.ts
@@ -10,6 +10,7 @@ import {
   receiveUiConnections,
   UI_CONTROL_CHANNEL_NAME,
 } from './ui-connections.js';
+import clusterConfig from '../vats/default-cluster.json';
 
 vi.mock('nanoid', () => ({
   nanoid: vi.fn(() => 'test-id'),
@@ -166,7 +167,7 @@ describe('ui-connections', () => {
         id: 'foo',
         payload: {
           method: 'getStatus',
-          params: { vats: [] },
+          params: { vats: [], clusterConfig },
         },
       }),
     );
diff --git a/packages/extension/src/ui/App.module.css b/packages/extension/src/ui/App.module.css
index c168cc121..3425ab4ad 100644
--- a/packages/extension/src/ui/App.module.css
+++ b/packages/extension/src/ui/App.module.css
@@ -6,6 +6,7 @@
   --color-gray-200: #f0f0f0;
   --color-gray-300: #ccc;
   --color-gray-600: #666;
+  --color-gray-800: #333;
   --color-primary: #4956f9;
   --color-success: #4caf50;
   --color-error: #f44336;
@@ -143,11 +144,17 @@ h6 {
   border: none;
 }
 
-.button:hover:not(:disabled) {
+.buttonBlack {
+  composes: button;
   background-color: var(--color-black);
   color: var(--color-white);
+  border: none;
 }
 
+.button:hover:not(:disabled) {
+  background-color: var(--color-gray-800);
+  color: var(--color-white);
+}
 .textButton {
   padding: 0;
   border: 0;
@@ -330,13 +337,6 @@ div + .sent {
   background: var(--color-gray-200);
 }
 
-.messageTemplates {
-  display: flex;
-  gap: var(--spacing-sm);
-  margin-bottom: var(--spacing-sm);
-  flex-wrap: wrap;
-}
-
 .messageInputRow {
   display: flex;
   gap: var(--spacing-sm);
@@ -472,3 +472,25 @@ div + .sent {
   display: flex;
   gap: var(--spacing-sm);
 }
+
+.configEditor {
+  margin: 0;
+  display: flex;
+  flex-direction: column;
+  gap: var(--spacing-sm);
+}
+
+.configTextarea {
+  font-family: monospace;
+  padding: var(--spacing-sm);
+  border: 1px solid var(--color-gray-300);
+  border-radius: var(--border-radius);
+  resize: vertical;
+  min-height: 200px;
+}
+
+.configEditorButtons {
+  display: flex;
+  gap: var(--spacing-sm);
+  justify-content: flex-end;
+}
diff --git a/packages/extension/src/ui/App.test.tsx b/packages/extension/src/ui/App.test.tsx
index 059e3b89e..5c0a64379 100644
--- a/packages/extension/src/ui/App.test.tsx
+++ b/packages/extension/src/ui/App.test.tsx
@@ -1,29 +1,11 @@
 import '@ocap/test-utils/mock-endoify';
-import { define } from '@metamask/superstruct';
-import type { VatId, VatConfig } from '@ocap/kernel';
+import { setupOcapKernelMock } from '@ocap/test-utils';
 import { render, screen, cleanup } from '@testing-library/react';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 
 import type { StreamState } from './hooks/useStream.js';
 
-const isVatId = vi.fn(
-  (input: unknown): input is VatId => typeof input === 'string',
-);
-
-const isVatConfig = vi.fn(
-  (input: unknown): input is VatConfig => typeof input === 'object',
-);
-
-vi.mock('@ocap/kernel', () => ({
-  isVatId,
-  isVatConfig,
-  VatCommandMethod: {
-    ping: 'ping',
-  },
-  KernelCommandMethod: {},
-  VatIdStruct: define<VatId>('VatId', isVatId),
-  VatConfigStruct: define<VatConfig>('VatConfig', isVatConfig),
-}));
+setupOcapKernelMock();
 
 vi.mock('./hooks/useStream.js', () => ({
   useStream: vi.fn(),
diff --git a/packages/extension/src/ui/components/ConfigEditor.test.tsx b/packages/extension/src/ui/components/ConfigEditor.test.tsx
new file mode 100644
index 000000000..a36e8df1d
--- /dev/null
+++ b/packages/extension/src/ui/components/ConfigEditor.test.tsx
@@ -0,0 +1,179 @@
+import {
+  render,
+  screen,
+  cleanup,
+  waitFor,
+  fireEvent,
+} from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+import { ConfigEditor } from './ConfigEditor.js';
+import type { KernelStatus } from '../../kernel-integration/messages.js';
+import clusterConfig from '../../vats/default-cluster.json';
+import { usePanelContext } from '../context/PanelContext.js';
+import { useKernelActions } from '../hooks/useKernelActions.js';
+
+const mockStatus = {
+  clusterConfig,
+  vats: [],
+};
+
+const mockLogMessage = vi.fn();
+
+const mockUsePanelContext = {
+  status: mockStatus,
+  logMessage: mockLogMessage,
+  messageContent: '',
+  setMessageContent: vi.fn(),
+  panelLogs: [],
+  clearLogs: vi.fn(),
+  sendMessage: vi.fn(),
+  selectedVatId: '1',
+  setSelectedVatId: vi.fn(),
+};
+
+vi.mock('../hooks/useKernelActions.js', () => ({
+  useKernelActions: vi.fn(),
+}));
+
+vi.mock('../context/PanelContext.js', () => ({
+  usePanelContext: vi.fn(),
+}));
+
+// Mock the CSS module
+vi.mock('../App.module.css', () => ({
+  default: {
+    configEditor: 'config-editor',
+    configTextarea: 'config-textarea',
+    configEditorButtons: 'config-editor-buttons',
+    buttonPrimary: 'button-primary',
+    buttonBlack: 'button-black',
+  },
+}));
+
+describe('ConfigEditor Component', () => {
+  const mockUpdateClusterConfig = vi.fn();
+  const mockReload = vi.fn();
+
+  beforeEach(() => {
+    cleanup();
+    vi.clearAllMocks();
+    vi.mocked(useKernelActions).mockReturnValue({
+      updateClusterConfig: mockUpdateClusterConfig,
+      reload: mockReload,
+      sendKernelCommand: vi.fn(),
+      terminateAllVats: vi.fn(),
+      clearState: vi.fn(),
+      launchVat: vi.fn(),
+    });
+    vi.mocked(usePanelContext).mockReturnValue(mockUsePanelContext);
+  });
+
+  it('renders nothing when status is not available', () => {
+    vi.mocked(usePanelContext).mockReturnValue({
+      ...mockUsePanelContext,
+      status: undefined,
+    });
+    const { container } = render(<ConfigEditor />);
+    expect(container).toBeEmptyDOMElement();
+  });
+
+  it('renders the config editor with initial config', () => {
+    render(<ConfigEditor />);
+    expect(screen.getByText('Cluster Config')).toBeInTheDocument();
+    const textarea = screen.getByRole('textbox');
+    expect(textarea).toHaveValue(
+      JSON.stringify(mockStatus.clusterConfig, null, 2),
+    );
+    expect(
+      screen.getByRole('button', { name: 'Update Config' }),
+    ).toBeInTheDocument();
+    expect(
+      screen.getByRole('button', { name: 'Update and Reload' }),
+    ).toBeInTheDocument();
+  });
+
+  it('updates textarea value when user types', async () => {
+    render(<ConfigEditor />);
+    const textarea = screen.getByRole('textbox');
+    fireEvent.change(textarea, { target: { value: 'test' } });
+    expect(textarea).toHaveValue('test');
+  });
+
+  it('updates config when "Update Config" is clicked', async () => {
+    mockUpdateClusterConfig.mockResolvedValue(undefined);
+    render(<ConfigEditor />);
+    const updateButton = screen.getByTestId('update-config');
+    await userEvent.click(updateButton);
+    expect(mockUpdateClusterConfig).toHaveBeenCalledWith(
+      mockStatus.clusterConfig,
+    );
+    expect(mockReload).not.toHaveBeenCalled();
+  });
+
+  it('updates config and reloads when "Update and Reload" is clicked', async () => {
+    mockUpdateClusterConfig.mockResolvedValue(undefined);
+    render(<ConfigEditor />);
+    const updateButton = screen.getByTestId('update-and-restart');
+    await userEvent.click(updateButton);
+    expect(mockUpdateClusterConfig).toHaveBeenCalledWith(
+      mockStatus.clusterConfig,
+    );
+    expect(mockReload).toHaveBeenCalled();
+  });
+
+  it('logs error when invalid JSON is submitted', async () => {
+    mockUpdateClusterConfig.mockRejectedValueOnce(new Error('Invalid JSON'));
+    render(<ConfigEditor />);
+    const textarea = screen.getByRole('textbox');
+    fireEvent.change(textarea, { target: { value: 'test' } });
+    const updateButton = screen.getByTestId('update-config');
+    await userEvent.click(updateButton);
+    expect(mockLogMessage).toHaveBeenCalledWith(
+      `SyntaxError: Unexpected token 'e', "test" is not valid JSON`,
+      'error',
+    );
+    expect(mockReload).not.toHaveBeenCalled();
+  });
+
+  it('logs error when update fails', async () => {
+    const error = new Error('Update failed');
+    mockUpdateClusterConfig.mockRejectedValueOnce(error);
+    render(<ConfigEditor />);
+    await userEvent.click(screen.getByTestId('update-config'));
+
+    await waitFor(() => {
+      expect(mockLogMessage).toHaveBeenCalledWith(error.toString(), 'error');
+    });
+  });
+
+  it('updates textarea when status changes', async () => {
+    const { rerender } = render(<ConfigEditor />);
+    const textarea = screen.getByRole('textbox');
+    expect(textarea).toHaveValue(
+      JSON.stringify(mockStatus.clusterConfig, null, 2),
+    );
+
+    const newStatus: KernelStatus = {
+      clusterConfig: {
+        ...clusterConfig,
+        bootstrap: 'updated-config',
+      },
+      vats: [],
+    };
+
+    vi.mocked(usePanelContext).mockReturnValue({
+      ...mockUsePanelContext,
+      status: newStatus,
+    });
+
+    rerender(<ConfigEditor />);
+
+    await waitFor(() => {
+      expect(textarea).toHaveValue(
+        JSON.stringify(newStatus.clusterConfig, null, 2),
+      );
+    });
+  });
+});
diff --git a/packages/extension/src/ui/components/ConfigEditor.tsx b/packages/extension/src/ui/components/ConfigEditor.tsx
new file mode 100644
index 000000000..9103067c6
--- /dev/null
+++ b/packages/extension/src/ui/components/ConfigEditor.tsx
@@ -0,0 +1,90 @@
+import type { ClusterConfig } from '@ocap/kernel';
+import { useCallback, useEffect, useMemo, useState } from 'react';
+
+import type { KernelStatus } from '../../kernel-integration/messages.js';
+import styles from '../App.module.css';
+import { usePanelContext } from '../context/PanelContext.js';
+import { useKernelActions } from '../hooks/useKernelActions.js';
+
+/**
+ * Component for editing the kernel cluster configuration.
+ *
+ * @param options - The component options
+ * @param options.status - The kernel status
+ * @returns A React component for editing the kernel cluster configuration.
+ */
+export const ConfigEditorInner: React.FC<{ status: KernelStatus }> = ({
+  status,
+}) => {
+  const { updateClusterConfig, reload } = useKernelActions();
+  const { logMessage } = usePanelContext();
+  const clusterConfig = useMemo(
+    () => JSON.stringify(status.clusterConfig, null, 2),
+    [status],
+  );
+  const [config, setConfig] = useState<string>(clusterConfig);
+
+  // Update the config when the status changes
+  useEffect(() => {
+    setConfig(clusterConfig);
+  }, [clusterConfig]);
+
+  const handleUpdate = useCallback(
+    (reloadKernel = false) => {
+      try {
+        const parsedConfig: ClusterConfig = JSON.parse(config);
+        updateClusterConfig(parsedConfig)
+          .then(() => reloadKernel && reload())
+          .catch((error) => {
+            logMessage(String(error), 'error');
+          });
+      } catch (error) {
+        logMessage(String(error), 'error');
+      }
+    },
+    [config, updateClusterConfig],
+  );
+
+  if (!config) {
+    return null;
+  }
+
+  return (
+    <div className={styles.configEditor}>
+      <h4>Cluster Config</h4>
+      <textarea
+        value={config}
+        onChange={(event) => setConfig(event.target.value)}
+        rows={10}
+        className={styles.configTextarea}
+        data-testid="config-textarea"
+      />
+      <div className={styles.configEditorButtons}>
+        <button
+          onClick={() => handleUpdate(false)}
+          className={styles.buttonPrimary}
+          data-testid="update-config"
+        >
+          Update Config
+        </button>
+        <button
+          onClick={() => handleUpdate(true)}
+          className={styles.buttonBlack}
+          data-testid="update-and-restart"
+        >
+          Update and Reload
+        </button>
+      </div>
+    </div>
+  );
+};
+
+export const ConfigEditor: React.FC = () => {
+  const { status } = usePanelContext();
+
+  if (!status) {
+    return null;
+  }
+
+  return <ConfigEditorInner status={status} />;
+};
diff --git a/packages/extension/src/ui/components/KernelControls.test.tsx b/packages/extension/src/ui/components/KernelControls.test.tsx
index a5a3f2265..58595187f 100644
--- a/packages/extension/src/ui/components/KernelControls.test.tsx
+++ b/packages/extension/src/ui/components/KernelControls.test.tsx
@@ -30,6 +30,7 @@ const mockUseKernelActions = (overrides = {}): void => {
     reload: vi.fn(),
     sendKernelCommand: vi.fn(),
     launchVat: vi.fn(),
+    updateClusterConfig: vi.fn(),
     ...overrides,
   });
 };
@@ -106,13 +107,13 @@ describe('KernelControls', () => {
     expect(clearState).toHaveBeenCalledTimes(1);
   });
 
-  it('calls reload when "Reload Default Sub-Cluster" button is clicked', async () => {
+  it('calls reload when "Reload Kernel" button is clicked', async () => {
     const reload = vi.fn();
     mockUseKernelActions({ reload });
     mockUseVats();
     render(<KernelControls />);
     const reloadButton = screen.getByRole('button', {
-      name: 'Reload Default Sub-Cluster',
+      name: 'Reload Kernel',
     });
     await userEvent.click(reloadButton);
     expect(reload).toHaveBeenCalledTimes(1);
diff --git a/packages/extension/src/ui/components/KernelControls.tsx b/packages/extension/src/ui/components/KernelControls.tsx
index bfeadf1d3..323956c2f 100644
--- a/packages/extension/src/ui/components/KernelControls.tsx
+++ b/packages/extension/src/ui/components/KernelControls.tsx
@@ -19,8 +19,8 @@ export const KernelControls: React.FC = () => {
       <button className={styles.buttonDanger} onClick={clearState}>
         Clear All State
       </button>
-      <button className={styles.buttonDanger} onClick={reload}>
-        Reload Default Sub-Cluster
+      <button className={styles.buttonBlack} onClick={reload}>
+        Reload Kernel
       </button>
     </div>
   );
diff --git a/packages/extension/src/ui/components/LaunchVat.test.tsx b/packages/extension/src/ui/components/LaunchVat.test.tsx
index eb03a1bd6..efa7bb479 100644
--- a/packages/extension/src/ui/components/LaunchVat.test.tsx
+++ b/packages/extension/src/ui/components/LaunchVat.test.tsx
@@ -25,6 +25,7 @@ describe('LaunchVat Component', () => {
       terminateAllVats: vi.fn(),
       clearState: vi.fn(),
       reload: vi.fn(),
+      updateClusterConfig: vi.fn(),
     });
   });
 
diff --git a/packages/extension/src/ui/components/MessagePanel.test.tsx b/packages/extension/src/ui/components/MessagePanel.test.tsx
index 17c7df1eb..acdd3c999 100644
--- a/packages/extension/src/ui/components/MessagePanel.test.tsx
+++ b/packages/extension/src/ui/components/MessagePanel.test.tsx
@@ -1,5 +1,4 @@
-import { define } from '@metamask/superstruct';
-import type { VatConfig, VatId } from '@ocap/kernel';
+import { setupOcapKernelMock } from '@ocap/test-utils';
 import { stringify } from '@ocap/utils';
 import { render, screen, cleanup } from '@testing-library/react';
 import userEvent from '@testing-library/user-event';
@@ -9,23 +8,7 @@ import { usePanelContext } from '../context/PanelContext.js';
 import type { PanelContextType } from '../context/PanelContext.js';
 import { useKernelActions } from '../hooks/useKernelActions.js';
 
-const isVatId = vi.fn(
-  (input: unknown): input is VatId => typeof input === 'string',
-);
-
-const isVatConfig = vi.fn(
-  (input: unknown): input is VatConfig => typeof input === 'object',
-);
-
-vi.mock('@ocap/kernel', () => ({
-  isVatId,
-  isVatConfig,
-  VatCommandMethod: {
-    ping: 'ping',
-  },
-  VatIdStruct: define<VatId>('VatId', isVatId),
-  VatConfigStruct: define<VatConfig>('VatConfig', isVatConfig),
-}));
+setupOcapKernelMock();
 
 vi.mock('../hooks/useKernelActions.js', () => ({
   useKernelActions: vi.fn(),
@@ -52,6 +35,7 @@ describe('MessagePanel Component', () => {
       clearState: vi.fn(),
       reload: vi.fn(),
       launchVat: vi.fn(),
+      updateClusterConfig: vi.fn(),
     });
     vi.mocked(usePanelContext).mockReturnValue({
       messageContent: '',
@@ -97,6 +81,21 @@ describe('MessagePanel Component', () => {
     expect(sendKernelCommand).toHaveBeenCalledTimes(1);
   });
 
+  it('calls sendKernelCommand when enter key is pressed', async () => {
+    vi.mocked(usePanelContext).mockReturnValue({
+      messageContent: '{"key": "value"}',
+      setMessageContent,
+      panelLogs: [],
+      clearLogs,
+    } as unknown as PanelContextType);
+    const { MessagePanel } = await import('./MessagePanel.js');
+    render(<MessagePanel />);
+    const inputField = screen.getByPlaceholderText('Enter message (as JSON)');
+    await userEvent.click(inputField);
+    await userEvent.keyboard('{Enter}');
+    expect(sendKernelCommand).toHaveBeenCalledTimes(1);
+  });
+
   it('renders panel logs with correct icons and messages', async () => {
     vi.mocked(usePanelContext).mockReturnValue({
       messageContent: '',
diff --git a/packages/extension/src/ui/components/MessagePanel.tsx b/packages/extension/src/ui/components/MessagePanel.tsx
index 9bc2b2f4e..a7494452b 100644
--- a/packages/extension/src/ui/components/MessagePanel.tsx
+++ b/packages/extension/src/ui/components/MessagePanel.tsx
@@ -1,5 +1,3 @@
-import type { KernelCommand } from '@ocap/kernel';
-import { stringify } from '@ocap/utils';
 import { useEffect, useRef } from 'react';
 
 import styles from '../App.module.css';
@@ -7,8 +5,6 @@ import { usePanelContext } from '../context/PanelContext.js';
 import type { OutputType } from '../context/PanelContext.js';
 import { useKernelActions } from '../hooks/useKernelActions.js';
 
-const commonMessages: Record<string, KernelCommand> = {};
-
 const getLogTypeIcon = (type: OutputType): string => {
   switch (type) {
     case 'received':
@@ -63,17 +59,6 @@ export const MessagePanel: React.FC = () => {
         </div>
       </div>
       <div className={styles.messageInputSection}>
-        <div className={styles.messageTemplates}>
-          {Object.entries(commonMessages).map(([name, template]) => (
-            <button
-              key={name}
-              className={styles.textButton}
-              onClick={() => setMessageContent(stringify(template, 0))}
-            >
-              {name}
-            </button>
-          ))}
-        </div>
         <div className={styles.messageInputRow}>
           <input
             className={styles.messageContent}
diff --git a/packages/extension/src/ui/components/VatManager.test.tsx b/packages/extension/src/ui/components/VatManager.test.tsx
index 4ddea76c8..55369c78a 100644
--- a/packages/extension/src/ui/components/VatManager.test.tsx
+++ b/packages/extension/src/ui/components/VatManager.test.tsx
@@ -1,11 +1,33 @@
+import '@ocap/test-utils/mock-endoify';
 import { cleanup, render, screen } from '@testing-library/react';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 
+import { ConfigEditor } from './ConfigEditor.jsx';
 import { KernelControls } from './KernelControls.jsx';
 import { LaunchVat } from './LaunchVat.jsx';
 import { VatManager } from './VatManager.jsx';
 import { VatTable } from './VatTable.jsx';
 
+vi.mock('../../kernel-integration/messages.js', () => ({
+  KernelControlMethod: {
+    sendMessage: 'sendMessage',
+    terminateAllVats: 'terminateAllVats',
+    clearState: 'clearState',
+    reload: 'reload',
+    launchVat: 'launchVat',
+  },
+}));
+
+vi.mock('../context/PanelContext.js', () => ({
+  usePanelContext: vi.fn(() => ({
+    status: {
+      clusterConfig: {
+        test: 'config',
+      },
+    },
+  })),
+}));
+
 // Mock the child components
 vi.mock('./KernelControls.jsx', () => ({
   KernelControls: vi.fn(() => <div data-testid="kernel-controls" />),
@@ -19,6 +41,10 @@ vi.mock('./VatTable.jsx', () => ({
   VatTable: vi.fn(() => <div data-testid="vat-table" />),
 }));
 
+vi.mock('./ConfigEditor.jsx', () => ({
+  ConfigEditor: vi.fn(() => <div data-testid="config-editor" />),
+}));
+
 vi.mock('../App.module.css', () => ({
   default: {
     headerSection: 'header-section',
@@ -38,11 +64,12 @@ describe('VatManager Component', () => {
   it('renders all child components in correct order', () => {
     render(<VatManager />);
 
-    const children = screen.getAllByTestId(/-controls|-table|-vat$/u);
-    expect(children).toHaveLength(3);
+    const children = screen.getAllByTestId(/-controls|-table|-vat|-editor$/u);
+    expect(children).toHaveLength(4);
     expect(children[0]).toHaveAttribute('data-testid', 'kernel-controls');
     expect(children[1]).toHaveAttribute('data-testid', 'vat-table');
     expect(children[2]).toHaveAttribute('data-testid', 'launch-vat');
+    expect(children[3]).toHaveAttribute('data-testid', 'config-editor');
   });
 
   it('renders header section with correct class', () => {
@@ -65,4 +92,9 @@ describe('VatManager Component', () => {
     render(<VatManager />);
     expect(LaunchVat).toHaveBeenCalled();
   });
+
+  it('renders ConfigEditor component', () => {
+    render(<VatManager />);
+    expect(ConfigEditor).toHaveBeenCalled();
+  });
 });
diff --git a/packages/extension/src/ui/components/VatManager.tsx b/packages/extension/src/ui/components/VatManager.tsx
index ba50a03c2..150baf127 100644
--- a/packages/extension/src/ui/components/VatManager.tsx
+++ b/packages/extension/src/ui/components/VatManager.tsx
@@ -1,3 +1,4 @@
+import { ConfigEditor } from './ConfigEditor.js';
 import { KernelControls } from './KernelControls.jsx';
 import { LaunchVat } from './LaunchVat.jsx';
 import { VatTable } from './VatTable.jsx';
@@ -12,6 +13,7 @@ export const VatManager: React.FC = () => {
       </div>
       <VatTable />
       <LaunchVat />
+      <ConfigEditor />
     </>
   );
 };
diff --git a/packages/extension/src/ui/components/VatTable.tsx b/packages/extension/src/ui/components/VatTable.tsx
index bb69fd328..1251b191a 100644
--- a/packages/extension/src/ui/components/VatTable.tsx
+++ b/packages/extension/src/ui/components/VatTable.tsx
@@ -13,7 +13,7 @@ export const VatTable: React.FC = () => {
 
   return (
     <div className={styles.table}>
-      <table>
+      <table data-testid="vat-table">
         <thead>
           <tr>
             <th>ID</th>
diff --git a/packages/extension/src/ui/context/PanelContext.tsx b/packages/extension/src/ui/context/PanelContext.tsx
index 68e15be4c..9364cd1a7 100644
--- a/packages/extension/src/ui/context/PanelContext.tsx
+++ b/packages/extension/src/ui/context/PanelContext.tsx
@@ -18,9 +18,8 @@ type PanelLog = {
 
 export type PanelContextType = {
   sendMessage: SendMessageFunction;
-  status: KernelStatus | null;
+  status: KernelStatus | undefined;
   logMessage: (message: string, type?: OutputType) => void;
-  setStatus: (status: KernelStatus) => void;
   messageContent: string;
   setMessageContent: (content: string) => void;
   panelLogs: PanelLog[];
@@ -38,7 +37,6 @@ export const PanelProvider: React.FC<{
   const [panelLogs, setPanelLogs] = useState<PanelLog[]>([]);
   const [messageContent, setMessageContent] = useState<string>('');
   const [selectedVatId, setSelectedVatId] = useState<VatId | undefined>();
-  const [status, setStatus] = useState<KernelStatus | null>(null);
 
   const logMessage = useCallback(
     (message: string, type: OutputType = 'received'): void => {
@@ -68,14 +66,13 @@ export const PanelProvider: React.FC<{
     [sendMessage],
   );
 
-  useStatusPolling(setStatus, sendMessage, 1000);
+  const status = useStatusPolling(sendMessage, 1000);
 
   return (
     <PanelContext.Provider
       value={{
         sendMessage: sendMessageWrapper,
         status,
-        setStatus,
         logMessage,
         messageContent,
         setMessageContent,
diff --git a/packages/extension/src/ui/hooks/useKernelActions.test.ts b/packages/extension/src/ui/hooks/useKernelActions.test.ts
index dcd245a8f..4ad60efc2 100644
--- a/packages/extension/src/ui/hooks/useKernelActions.test.ts
+++ b/packages/extension/src/ui/hooks/useKernelActions.test.ts
@@ -1,6 +1,8 @@
 import { renderHook, waitFor } from '@testing-library/react';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 
+import clusterConfig from '../../vats/default-cluster.json';
+
 vi.mock('../context/PanelContext.js', () => ({
   usePanelContext: vi.fn(),
 }));
@@ -12,6 +14,7 @@ vi.mock('../../kernel-integration/messages.js', () => ({
     clearState: 'clearState',
     reload: 'reload',
     launchVat: 'launchVat',
+    updateClusterConfig: 'updateClusterConfig',
   },
 }));
 
@@ -33,8 +36,7 @@ describe('useKernelActions', () => {
       messageContent: mockMessageContent,
       selectedVatId: mockSelectedVatId,
       setMessageContent: vi.fn(),
-      status: null,
-      setStatus: vi.fn(),
+      status: undefined,
       panelLogs: [],
       setSelectedVatId: vi.fn(),
       clearLogs: vi.fn(),
@@ -69,8 +71,7 @@ describe('useKernelActions', () => {
         messageContent: mockMessageContent,
         selectedVatId: undefined,
         setMessageContent: vi.fn(),
-        status: null,
-        setStatus: vi.fn(),
+        status: undefined,
         panelLogs: [],
         setSelectedVatId: vi.fn(),
         clearLogs: vi.fn(),
@@ -259,9 +260,7 @@ describe('useKernelActions', () => {
       const { result } = renderHook(() => useKernelActions());
       const bundleUrl = 'test-bundle-url';
       const vatName = 'test-vat';
-
       mockSendMessage.mockRejectedValueOnce(new Error());
-
       result.current.launchVat(bundleUrl, vatName);
       await waitFor(() => {
         expect(mockLogMessage).toHaveBeenCalledWith(
@@ -271,4 +270,29 @@ describe('useKernelActions', () => {
       });
     });
   });
+
+  describe('updateClusterConfig', () => {
+    it('sends update cluster config command with correct parameters', async () => {
+      const { useKernelActions } = await import('./useKernelActions.js');
+      const { result } = renderHook(() => useKernelActions());
+      mockSendMessage.mockResolvedValueOnce({ success: true });
+      await result.current.updateClusterConfig(clusterConfig);
+      expect(mockSendMessage).toHaveBeenCalledWith({
+        method: 'updateClusterConfig',
+        params: { config: clusterConfig },
+      });
+      expect(mockLogMessage).toHaveBeenCalledWith('Config updated', 'success');
+    });
+
+    it('logs error on failure', async () => {
+      const { useKernelActions } = await import('./useKernelActions.js');
+      const { result } = renderHook(() => useKernelActions());
+      mockSendMessage.mockRejectedValueOnce(new Error());
+      await result.current.updateClusterConfig(clusterConfig);
+      expect(mockLogMessage).toHaveBeenCalledWith(
+        'Failed to update config',
+        'error',
+      );
+    });
+  });
 });
diff --git a/packages/extension/src/ui/hooks/useKernelActions.ts b/packages/extension/src/ui/hooks/useKernelActions.ts
index 37ae10eec..35dcda98e 100644
--- a/packages/extension/src/ui/hooks/useKernelActions.ts
+++ b/packages/extension/src/ui/hooks/useKernelActions.ts
@@ -1,9 +1,9 @@
+import type { ClusterConfig } from '@ocap/kernel';
 import { stringify } from '@ocap/utils';
 import { useCallback } from 'react';
 
 import { KernelControlMethod } from '../../kernel-integration/messages.js';
 import { usePanelContext } from '../context/PanelContext.js';
-
 /**
  * Hook for handling kernel actions.
  *
@@ -15,6 +15,7 @@ export function useKernelActions(): {
   clearState: () => void;
   reload: () => void;
   launchVat: (bundleUrl: string, vatName: string) => void;
+  updateClusterConfig: (config: ClusterConfig) => Promise<void>;
 } {
   const { sendMessage, logMessage, messageContent, selectedVatId } =
     usePanelContext();
@@ -90,11 +91,27 @@ export function useKernelActions(): {
     [sendMessage, logMessage],
   );
 
+  /**
+   * Updates the cluster config.
+   */
+  const updateClusterConfig = useCallback(
+    async (config: ClusterConfig) => {
+      return sendMessage({
+        method: KernelControlMethod.updateClusterConfig,
+        params: { config },
+      })
+        .then(() => logMessage('Config updated', 'success'))
+        .catch(() => logMessage('Failed to update config', 'error'));
+    },
+    [sendMessage, logMessage],
+  );
+
   return {
     sendKernelCommand,
     terminateAllVats,
     clearState,
     reload,
     launchVat,
+    updateClusterConfig,
   };
 }
diff --git a/packages/extension/src/ui/hooks/useStatusPolling.test.ts b/packages/extension/src/ui/hooks/useStatusPolling.test.ts
index 46151ef78..f23019edc 100644
--- a/packages/extension/src/ui/hooks/useStatusPolling.test.ts
+++ b/packages/extension/src/ui/hooks/useStatusPolling.test.ts
@@ -1,6 +1,8 @@
-import { renderHook } from '@testing-library/react';
+import { renderHook, waitFor } from '@testing-library/react';
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 
+import clusterConfig from '../../vats/default-cluster.json';
+
 vi.mock('../../kernel-integration/messages.js', () => ({
   KernelControlMethod: {
     getStatus: 'getStatus',
@@ -18,41 +20,22 @@ vi.mock('../utils.js', () => ({
 }));
 
 describe('useStatusPolling', () => {
-  const mockSetStatus = vi.fn();
   const mockSendMessage = vi.fn();
   const mockInterval = 100;
 
-  beforeEach(() => {
-    vi.useFakeTimers({
-      now: Date.now(),
-      toFake: ['setInterval', 'clearInterval'],
-    });
-  });
-
-  afterEach(() => {
-    vi.clearAllTimers();
-    vi.useRealTimers();
-  });
-
-  it('should not fetch status when sendMessage is undefined', async () => {
-    const { useStatusPolling } = await import('./useStatusPolling.js');
-    renderHook(() => useStatusPolling(mockSetStatus, undefined, mockInterval));
-    vi.advanceTimersByTime(mockInterval);
-    expect(mockSetStatus).not.toHaveBeenCalled();
-  });
-
   it('should start polling and fetch initial status', async () => {
-    const { useStatusPolling } = await import('./useStatusPolling.js');
-    const mockStatus = { vats: [] };
+    const mockStatus = { vats: [], clusterConfig };
     mockSendMessage.mockResolvedValueOnce(mockStatus);
     vi.mocked(await import('../utils.js')).isErrorResponse.mockReturnValue(
       false,
     );
-    renderHook(() => useStatusPolling(mockSetStatus, mockSendMessage, 100));
+    const { useStatusPolling } = await import('./useStatusPolling.js');
+    const { result } = renderHook(() => useStatusPolling(mockSendMessage, 100));
     expect(mockSendMessage).toHaveBeenCalledWith({
       method: 'getStatus',
       params: null,
     });
+    await waitFor(() => expect(result.current).toStrictEqual(mockStatus));
   });
 
   it('should handle error responses', async () => {
@@ -62,14 +45,11 @@ describe('useStatusPolling', () => {
     vi.mocked(await import('../utils.js')).isErrorResponse.mockReturnValue(
       true,
     );
-    renderHook(() =>
-      useStatusPolling(mockSetStatus, mockSendMessage, mockInterval),
-    );
+    renderHook(() => useStatusPolling(mockSendMessage, mockInterval));
     expect(mockSendMessage).toHaveBeenCalledWith({
       method: 'getStatus',
       params: null,
     });
-    expect(mockSetStatus).not.toHaveBeenCalled();
     expect(
       vi.mocked(await import('../services/logger.js')).logger.error,
     ).toHaveBeenCalledWith('Failed to fetch status:', new Error('Test error'));
@@ -79,49 +59,58 @@ describe('useStatusPolling', () => {
     const { useStatusPolling } = await import('./useStatusPolling.js');
     const error = new Error('Network error');
     mockSendMessage.mockRejectedValueOnce(error);
-    renderHook(() =>
-      useStatusPolling(mockSetStatus, mockSendMessage, mockInterval),
-    );
+    renderHook(() => useStatusPolling(mockSendMessage, mockInterval));
     expect(mockSendMessage).toHaveBeenCalledWith({
       method: 'getStatus',
       params: null,
     });
-    expect(mockSetStatus).not.toHaveBeenCalled();
     expect(
       vi.mocked(await import('../services/logger.js')).logger.error,
     ).toHaveBeenCalledWith('Failed to fetch status:', error);
   });
 
-  it('should poll at specified intervals', async () => {
-    const { useStatusPolling } = await import('./useStatusPolling.js');
-    const mockStatus = { vats: [] };
-    mockSendMessage.mockResolvedValue(mockStatus);
-    vi.mocked(await import('../utils.js')).isErrorResponse.mockReturnValue(
-      false,
-    );
-    renderHook(() =>
-      useStatusPolling(mockSetStatus, mockSendMessage, mockInterval),
-    );
-    expect(mockSendMessage).toHaveBeenCalledTimes(1);
-    vi.advanceTimersByTime(mockInterval);
-    expect(mockSendMessage).toHaveBeenCalledTimes(2);
-    vi.advanceTimersByTime(mockInterval);
-    expect(mockSendMessage).toHaveBeenCalledTimes(3);
-  });
+  describe('polling', () => {
+    beforeEach(() => {
+      vi.useFakeTimers({
+        now: Date.now(),
+        toFake: ['setInterval', 'clearInterval'],
+      });
+    });
 
-  it('should cleanup interval on unmount', async () => {
-    const { useStatusPolling } = await import('./useStatusPolling.js');
-    const mockStatus = { vats: [] };
-    mockSendMessage.mockResolvedValue(mockStatus);
-    vi.mocked(await import('../utils.js')).isErrorResponse.mockReturnValue(
-      false,
-    );
-    const { unmount } = renderHook(() =>
-      useStatusPolling(mockSetStatus, mockSendMessage, mockInterval),
-    );
-    expect(mockSendMessage).toHaveBeenCalledTimes(1);
-    unmount();
-    vi.advanceTimersByTime(mockInterval * 2);
-    expect(mockSendMessage).toHaveBeenCalledTimes(1);
+    afterEach(() => {
+      vi.clearAllTimers();
+      vi.useRealTimers();
+    });
+
+    it('should poll at specified intervals', async () => {
+      const { useStatusPolling } = await import('./useStatusPolling.js');
+      const mockStatus = { vats: [], clusterConfig };
+      mockSendMessage.mockResolvedValue(mockStatus);
+      vi.mocked(await import('../utils.js')).isErrorResponse.mockReturnValue(
+        false,
+      );
+      renderHook(() => useStatusPolling(mockSendMessage, mockInterval));
+      expect(mockSendMessage).toHaveBeenCalledTimes(1);
+      vi.advanceTimersByTime(mockInterval);
+      expect(mockSendMessage).toHaveBeenCalledTimes(2);
+      vi.advanceTimersByTime(mockInterval);
+      expect(mockSendMessage).toHaveBeenCalledTimes(3);
+    });
+
+    it('should cleanup interval on unmount', async () => {
+      const { useStatusPolling } = await import('./useStatusPolling.js');
+      const mockStatus = { vats: [] };
+      mockSendMessage.mockResolvedValue(mockStatus);
+      vi.mocked(await import('../utils.js')).isErrorResponse.mockReturnValue(
+        false,
+      );
+      const { unmount } = renderHook(() =>
+        useStatusPolling(mockSendMessage, mockInterval),
+      );
+      expect(mockSendMessage).toHaveBeenCalledTimes(1);
+      unmount();
+      vi.advanceTimersByTime(mockInterval * 2);
+      expect(mockSendMessage).toHaveBeenCalledTimes(1);
+    });
   });
 });
diff --git a/packages/extension/src/ui/hooks/useStatusPolling.ts b/packages/extension/src/ui/hooks/useStatusPolling.ts
index 3861b4e8c..42d6da5da 100644
--- a/packages/extension/src/ui/hooks/useStatusPolling.ts
+++ b/packages/extension/src/ui/hooks/useStatusPolling.ts
@@ -1,4 +1,4 @@
-import { useEffect, useRef } from 'react';
+import { useEffect, useRef, useState } from 'react';
 
 import type { StreamState } from './useStream.js';
 import { KernelControlMethod } from '../../kernel-integration/messages.js';
@@ -9,16 +9,17 @@ import { isErrorResponse } from '../utils.js';
 /**
  * Hook to start polling for kernel status
  *
- * @param setStatus - Function to set the kernel status
  * @param sendMessage - Function to send a message to the kernel
  * @param interval - Polling interval in milliseconds
+ *
+ * @returns The kernel status
  */
 export const useStatusPolling = (
-  setStatus: (status: KernelStatus) => void,
   sendMessage: StreamState['sendMessage'],
   interval: number = 1000,
-): void => {
+): KernelStatus | undefined => {
   const pollingRef = useRef<NodeJS.Timeout | null>(null);
+  const [status, setStatus] = useState<KernelStatus>();
 
   /**
    * Effect to start polling for kernel status.
@@ -29,14 +30,14 @@ export const useStatusPolling = (
         return;
       }
       try {
-        const status = await sendMessage({
+        const result = await sendMessage({
           method: KernelControlMethod.getStatus,
           params: null,
         });
-        if (isErrorResponse(status)) {
-          throw new Error(status.error);
+        if (isErrorResponse(result)) {
+          throw new Error(result.error);
         }
-        setStatus(status);
+        setStatus(result);
       } catch (error) {
         logger.error('Failed to fetch status:', error);
       }
@@ -53,5 +54,7 @@ export const useStatusPolling = (
         clearInterval(pollingRef.current);
       }
     };
-  }, [sendMessage, setStatus, interval]);
+  }, [sendMessage, interval]);
+
+  return status;
 };
diff --git a/packages/extension/src/ui/hooks/useVats.test.ts b/packages/extension/src/ui/hooks/useVats.test.ts
index 8642df8b9..4a53cfbeb 100644
--- a/packages/extension/src/ui/hooks/useVats.test.ts
+++ b/packages/extension/src/ui/hooks/useVats.test.ts
@@ -1,4 +1,5 @@
 import type { VatConfig } from '@ocap/kernel';
+import { setupOcapKernelMock } from '@ocap/test-utils';
 import { renderHook, waitFor } from '@testing-library/react';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 
@@ -16,11 +17,7 @@ vi.mock('../../kernel-integration/messages.js', () => ({
   },
 }));
 
-vi.mock('@ocap/kernel', () => ({
-  VatCommandMethod: {
-    ping: 'ping',
-  },
-}));
+setupOcapKernelMock();
 
 vi.mock('@ocap/utils', () => ({
   stringify: JSON.stringify,
diff --git a/packages/extension/src/vats/default-cluster.json b/packages/extension/src/vats/default-cluster.json
new file mode 100644
index 000000000..fdd917ff3
--- /dev/null
+++ b/packages/extension/src/vats/default-cluster.json
@@ -0,0 +1,24 @@
+{
+  "bootstrap": "alice",
+  "forceReset": true,
+  "vats": {
+    "alice": {
+      "bundleSpec": "http://localhost:3000/sample-vat.bundle",
+      "parameters": {
+        "name": "Alice"
+      }
+    },
+    "bob": {
+      "bundleSpec": "http://localhost:3000/sample-vat.bundle",
+      "parameters": {
+        "name": "Bob"
+      }
+    },
+    "carol": {
+      "bundleSpec": "http://localhost:3000/sample-vat.bundle",
+      "parameters": {
+        "name": "Carol"
+      }
+    }
+  }
+}
diff --git a/packages/extension/test/e2e/popup.test.ts b/packages/extension/test/e2e/vat-manager.test.ts
similarity index 65%
rename from packages/extension/test/e2e/popup.test.ts
rename to packages/extension/test/e2e/vat-manager.test.ts
index 457fe2469..f8c5007ba 100644
--- a/packages/extension/test/e2e/popup.test.ts
+++ b/packages/extension/test/e2e/vat-manager.test.ts
@@ -1,9 +1,10 @@
 import { test, expect } from '@playwright/test';
 import type { Page, BrowserContext } from '@playwright/test';
 
+import clusterConfig from '../../src/vats/default-cluster.json' assert { type: 'json' };
 import { makeLoadExtension } from '../helpers/extension';
 
-test.describe('Kernel Panel', () => {
+test.describe('Vat Manager', () => {
   let extensionContext: BrowserContext;
   let popupPage: Page;
 
@@ -37,7 +38,6 @@ test.describe('Kernel Panel', () => {
       'http://localhost:3000/sample-vat.bundle',
     );
     await popupPage.click('button:text("Launch Vat")');
-    await popupPage.pause();
     await expect(popupPage.locator('#root')).toContainText(
       `Launched vat "${name}"`,
     );
@@ -132,4 +132,54 @@ test.describe('Kernel Panel', () => {
     await launchVat('test-vat-new');
     await expect(popupPage.locator('table tr')).toHaveCount(2); // Header + 1 row
   });
+
+  test('should reload kernel state and load default vats', async () => {
+    await expect(
+      popupPage.locator('button:text("Reload Kernel")'),
+    ).toBeVisible();
+    await popupPage.click('button:text("Reload Kernel")');
+    await expect(popupPage.locator('#root')).toContainText(
+      'Default sub-cluster reloaded',
+    );
+    // Verify the table is visible and has the correct number of rows (header + vats)
+    const vatTable = popupPage.locator('[data-testid="vat-table"]');
+    await expect(vatTable).toBeVisible();
+    await expect(vatTable.locator('tr')).toHaveCount(
+      Object.keys(clusterConfig.vats).length + 1, // +1 for header row
+    );
+    // Verify each default vat is present in the table
+    for (const [, vatConfig] of Object.entries(clusterConfig.vats)) {
+      await expect(vatTable).toContainText(vatConfig.parameters.name);
+      await expect(vatTable).toContainText(vatConfig.bundleSpec);
+    }
+  });
+
+  test('should handle cluster configuration updates', async () => {
+    // Check initial config is visible and matches clusterConfig
+    const configTextarea = popupPage.locator('[data-testid="config-textarea"]');
+    await expect(configTextarea).toBeVisible();
+    await expect(configTextarea).toHaveValue(
+      JSON.stringify(clusterConfig, null, 2),
+    );
+    // Test invalid JSON handling
+    await configTextarea.fill('{ invalid json }');
+    await popupPage.click('button:text("Update Config")');
+    await expect(popupPage.locator('#root')).toContainText('SyntaxError');
+    // Verify original vats still exist
+    const vatTable = popupPage.locator('[data-testid="vat-table"]');
+    const firstVatKey = Object.keys(
+      clusterConfig.vats,
+    )[0] as keyof typeof clusterConfig.vats;
+    const originalVatName = clusterConfig.vats[firstVatKey].parameters.name;
+    await expect(vatTable).toContainText(originalVatName);
+    // Modify config with new vat name
+    const modifiedConfig = structuredClone(clusterConfig);
+    modifiedConfig.vats[firstVatKey].parameters.name = 'SuperAlice';
+    // Update config and reload
+    await configTextarea.fill(JSON.stringify(modifiedConfig, null, 2));
+    await popupPage.click('button:text("Update Config")');
+    await popupPage.click('button:text("Reload Kernel")');
+    // Verify new vat name appears
+    await expect(vatTable).toContainText('SuperAlice');
+  });
 });
diff --git a/packages/extension/test/helpers/extension.ts b/packages/extension/test/helpers/extension.ts
index 5baffb56a..4412c93f6 100644
--- a/packages/extension/test/helpers/extension.ts
+++ b/packages/extension/test/helpers/extension.ts
@@ -1,4 +1,3 @@
-import { delay } from '@ocap/test-utils';
 import { chromium } from '@playwright/test';
 import type { BrowserContext, Page } from '@playwright/test';
 import { rm } from 'fs/promises';
@@ -49,7 +48,7 @@ export const makeLoadExtension = async (): Promise<{
   });
 
   // Wait for the extension to be loaded
-  await delay(1000);
+  await new Promise((resolve) => setTimeout(resolve, 1000));
 
   const chromeExtensionURLIdMatcher = /^chrome-extension:\/\/([^/]+)/u;
   const serviceWorkers = browserContext.serviceWorkers();
diff --git a/packages/kernel/src/Kernel.test.ts b/packages/kernel/src/Kernel.test.ts
index e41fdc886..f2c5909eb 100644
--- a/packages/kernel/src/Kernel.test.ts
+++ b/packages/kernel/src/Kernel.test.ts
@@ -26,7 +26,17 @@ describe('Kernel', () => {
   let mockKVStore: KVStore;
 
   const mockVatConfig: VatConfig = { sourceSpec: 'not-really-there.js' };
-
+  const mockClusterConfig = {
+    bootstrap: 'alice',
+    vats: {
+      alice: {
+        bundleSpec: 'http://localhost:3000/sample-vat.bundle',
+        parameters: {
+          name: 'Alice',
+        },
+      },
+    },
+  };
   beforeEach(() => {
     mockStream = {
       write: vi.fn(),
@@ -252,4 +262,33 @@ describe('Kernel', () => {
 
     it.todo('throws if the stream throws');
   });
+
+  describe('reload()', () => {
+    it('should reload with current config when config exists', async () => {
+      const kernel = new Kernel(mockStream, mockWorkerService, mockKVStore);
+      kernel.clusterConfig = mockClusterConfig;
+      await kernel.launchVat(mockVatConfig);
+      const workerTerminateAllMock = vi
+        .spyOn(mockWorkerService, 'terminateAll')
+        .mockResolvedValue(undefined);
+      await kernel.reload();
+      expect(terminateMock).toHaveBeenCalledTimes(1);
+      expect(workerTerminateAllMock).toHaveBeenCalledOnce();
+      expect(initMock).toHaveBeenCalledTimes(2); // Initial launch + reload
+      expect(launchWorkerMock).toHaveBeenCalledTimes(2);
+    });
+
+    it('should throw if no config exists', async () => {
+      const kernel = new Kernel(mockStream, mockWorkerService, mockKVStore);
+      await expect(kernel.reload()).rejects.toThrow('no subcluster to reload');
+    });
+
+    it('should propagate errors from terminateAllVats', async () => {
+      const kernel = new Kernel(mockStream, mockWorkerService, mockKVStore);
+      kernel.clusterConfig = mockClusterConfig;
+      const error = new Error('Termination failed');
+      vi.spyOn(mockWorkerService, 'terminateAll').mockRejectedValueOnce(error);
+      await expect(kernel.reload()).rejects.toThrow(error);
+    });
+  });
 });
diff --git a/packages/kernel/src/Kernel.ts b/packages/kernel/src/Kernel.ts
index e277f52d5..bc7a72d02 100644
--- a/packages/kernel/src/Kernel.ts
+++ b/packages/kernel/src/Kernel.ts
@@ -98,28 +98,30 @@ export class Kernel {
    * @param commandStream - Command channel from whatever external software is driving the kernel.
    * @param vatWorkerService - Service to create a worker in which a new vat can run.
    * @param rawStorage - A KV store for holding the kernel's persistent state.
-   * @param logger - Optional logger for error and diagnostic output.
+   * @param options - Options for the kernel constructor.
+   * @param options.resetStorage - If true, the storage will be cleared.
+   * @param options.logger - Optional logger for error and diagnostic output.
    */
   constructor(
     commandStream: DuplexStream<KernelCommand, KernelCommandReply>,
     vatWorkerService: VatWorkerService,
     rawStorage: KVStore,
-    logger?: Logger,
+    options: {
+      resetStorage?: boolean;
+      logger?: Logger;
+    } = {},
   ) {
     this.#mostRecentSubcluster = null;
     this.#commandStream = commandStream;
     this.#vats = new Map();
     this.#vatWorkerService = vatWorkerService;
 
-    // XXX Warning: Clearing storage here is a hack to aid development
-    // debugging, wherein extension reloads are almost exclusively used for
-    // retrying after tweaking some fix. The kernel must not be shipped with the
-    // following line present, as it will prevent the accumulation of long term
-    // kernel state.
-    rawStorage.clear();
+    if (options.resetStorage) {
+      rawStorage.clear();
+    }
 
     this.#storage = makeKernelStore(rawStorage);
-    this.#logger = logger ?? makeLogger('[ocap kernel]');
+    this.#logger = options.logger ?? makeLogger('[ocap kernel]');
     this.#runQueueLength = this.#storage.runQueueLength();
     this.#wakeUpTheRunQueue = null;
   }
@@ -717,23 +719,16 @@ export class Kernel {
   }
 
   /**
-   * Launch a new subcluster with the same configuration as the most recently
-   * launched existing subcluster.
-   *
-   * XXX This is an ugly hack for debugging purposes only. It's here so that you
-   * can set breakpoints in code associated with the creation and launching of
-   * vats. It proved necessary because the extension reload mechanism only gives
-   * control to the debugger after the first default subcluster has already been
-   * created and bootstrapped. Eventually this should go away -- I presume there
-   * must be *some* established procedure for debugging extensions that would
-   * make this unnecessary (people who develop extensions generally need to
-   * debug them, one might think), but if so I haven't been able to find out
-   * what it is.
+   * Reload the kernel.
    */
   async reload(): Promise<void> {
-    if (this.#mostRecentSubcluster) {
-      await this.launchSubcluster(this.#mostRecentSubcluster);
+    if (!this.#mostRecentSubcluster) {
+      throw Error('no subcluster to reload');
     }
+
+    await this.terminateAllVats();
+
+    await this.launchSubcluster(this.#mostRecentSubcluster);
   }
 
   /**
@@ -779,5 +774,24 @@ export class Kernel {
     }
     return vat;
   }
+
+  /**
+   * Update the current cluster configuration
+   *
+   * @param config - The new cluster configuration
+   */
+  set clusterConfig(config: ClusterConfig) {
+    isClusterConfig(config) || Fail`invalid cluster config`;
+    this.#mostRecentSubcluster = config;
+  }
+
+  /**
+   * Get the current cluster configuration
+   *
+   * @returns The current cluster configuration
+   */
+  get clusterConfig(): ClusterConfig | null {
+    return this.#mostRecentSubcluster;
+  }
 }
 harden(Kernel);
diff --git a/packages/kernel/src/index.test.ts b/packages/kernel/src/index.test.ts
index 4f6061db3..6ce06e4d4 100644
--- a/packages/kernel/src/index.test.ts
+++ b/packages/kernel/src/index.test.ts
@@ -1,11 +1,11 @@
 import { describe, it, expect } from 'vitest';
-import '@ocap/test-utils';
 
 import * as indexModule from './index.js';
 
 describe('index', () => {
   it('has the expected exports', () => {
     expect(Object.keys(indexModule).sort()).toStrictEqual([
+      'ClusterConfigStruct',
       'Kernel',
       'KernelCommandMethod',
       'KernelSendVatCommandStruct',
diff --git a/packages/kernel/src/index.ts b/packages/kernel/src/index.ts
index 1ba543bb2..87fb5cd27 100644
--- a/packages/kernel/src/index.ts
+++ b/packages/kernel/src/index.ts
@@ -11,4 +11,10 @@ export type {
   ClusterConfig,
   VatConfig,
 } from './types.js';
-export { isVatId, VatIdStruct, isVatConfig, VatConfigStruct } from './types.js';
+export {
+  isVatId,
+  VatIdStruct,
+  isVatConfig,
+  VatConfigStruct,
+  ClusterConfigStruct,
+} from './types.js';
diff --git a/packages/kernel/src/types.ts b/packages/kernel/src/types.ts
index 0875b985a..ca6335cb3 100644
--- a/packages/kernel/src/types.ts
+++ b/packages/kernel/src/types.ts
@@ -12,7 +12,9 @@ import {
   record,
   union,
   literal,
+  boolean,
 } from '@metamask/superstruct';
+import type { Infer } from '@metamask/superstruct';
 import type { Json } from '@metamask/utils';
 import { UnsafeJsonStruct } from '@metamask/utils';
 import type { DuplexStream } from '@ocap/streams';
@@ -265,18 +267,15 @@ export const isVatConfig = (value: unknown): value is VatConfig =>
 
 export type VatConfigTable = Record<string, VatConfig>;
 
-export type ClusterConfig = {
-  bootstrap?: string;
-  vats: VatConfigTable;
-  bundles?: VatConfigTable;
-};
-
 export const ClusterConfigStruct = object({
-  bootstrap: optional(string()),
+  bootstrap: string(),
+  forceReset: optional(boolean()),
   vats: record(string(), VatConfigStruct),
   bundles: optional(record(string(), VatConfigStruct)),
 });
 
+export type ClusterConfig = Infer<typeof ClusterConfigStruct>;
+
 export const isClusterConfig = (value: unknown): value is ClusterConfig =>
   is(value, ClusterConfigStruct);
 
diff --git a/packages/test-utils/package.json b/packages/test-utils/package.json
index 3791cd85a..dc0d415fb 100644
--- a/packages/test-utils/package.json
+++ b/packages/test-utils/package.json
@@ -28,6 +28,7 @@
     "@metamask/eslint-config": "^14.0.0",
     "@metamask/eslint-config-nodejs": "^14.0.0",
     "@metamask/eslint-config-typescript": "^14.0.0",
+    "@metamask/superstruct": "^3.1.0",
     "@ocap/cli": "workspace:^",
     "@typescript-eslint/eslint-plugin": "^8.8.1",
     "@typescript-eslint/parser": "^8.8.1",
diff --git a/packages/test-utils/src/env/mock-kernel.ts b/packages/test-utils/src/env/mock-kernel.ts
new file mode 100644
index 000000000..8b8c09cce
--- /dev/null
+++ b/packages/test-utils/src/env/mock-kernel.ts
@@ -0,0 +1,79 @@
+import {
+  object,
+  define,
+  literal,
+  string,
+  optional,
+  boolean,
+  record,
+} from '@metamask/superstruct';
+import { vi } from 'vitest';
+
+type ResetMocks = () => void;
+type SetMockBehavior = (options: {
+  isVatConfig?: boolean;
+  isVatId?: boolean;
+}) => void;
+
+export const setupOcapKernelMock = (): {
+  resetMocks: ResetMocks;
+  setMockBehavior: SetMockBehavior;
+} => {
+  let isVatConfigMock = true;
+  let isVatIdMock = true;
+
+  // Mock implementation
+  vi.doMock('@ocap/kernel', () => {
+    const VatIdStruct = define<unknown>('VatId', () => isVatIdMock);
+    const VatConfigStruct = define<unknown>('VatConfig', () => isVatConfigMock);
+
+    return {
+      isKernelCommand: () => true,
+      isVatId: () => isVatIdMock,
+      isVatConfig: () => isVatConfigMock,
+      VatIdStruct,
+      VatConfigStruct,
+      ClusterConfigStruct: object({
+        bootstrap: string(),
+        forceReset: optional(boolean()),
+        vats: record(string(), VatConfigStruct),
+        bundles: optional(record(string(), VatConfigStruct)),
+      }),
+      KernelSendMessageStruct: object({
+        id: literal('v0'),
+        payload: object({
+          method: literal('ping'),
+          params: literal(null),
+        }),
+      }),
+      isVatCommandReply: vi.fn(() => true),
+      VatCommandMethod: {
+        ping: 'ping',
+      },
+      KernelCommandMethod: {},
+      VatWorkerServiceCommandMethod: {
+        launch: 'launch',
+        terminate: 'terminate',
+        terminateAll: 'terminateAll',
+      },
+    };
+  });
+
+  return {
+    resetMocks: (): void => {
+      isVatConfigMock = true;
+      isVatIdMock = true;
+    },
+    setMockBehavior: (options: {
+      isVatConfig?: boolean;
+      isVatId?: boolean;
+    }): void => {
+      if (typeof options.isVatConfig === 'boolean') {
+        isVatConfigMock = options.isVatConfig;
+      }
+      if (typeof options.isVatId === 'boolean') {
+        isVatIdMock = options.isVatId;
+      }
+    },
+  };
+};
diff --git a/packages/test-utils/src/index.ts b/packages/test-utils/src/index.ts
index cddc2ccad..f9990263b 100644
--- a/packages/test-utils/src/index.ts
+++ b/packages/test-utils/src/index.ts
@@ -1,6 +1,8 @@
 export { delay } from './delay.js';
 export { makeErrorMatcherFactory } from './errors.js';
 export { makePromiseKitMock } from './promise-kit.js';
+export { fetchMock } from './env/fetch-mock.js';
+export * from './env/mock-kernel.js';
 
 if (typeof self === 'undefined') {
   // @ts-expect-error error concerns the browser but this will only run in Node
diff --git a/packages/utils/package.json b/packages/utils/package.json
index c8a5080c2..5cf3ea52c 100644
--- a/packages/utils/package.json
+++ b/packages/utils/package.json
@@ -53,7 +53,9 @@
     "@metamask/eslint-config": "^14.0.0",
     "@metamask/eslint-config-nodejs": "^14.0.0",
     "@metamask/eslint-config-typescript": "^14.0.0",
+    "@metamask/superstruct": "^3.1.0",
     "@ocap/cli": "workspace:^",
+    "@ocap/test-utils": "workspace:^",
     "@ts-bridge/cli": "^0.6.2",
     "@ts-bridge/shims": "^0.1.1",
     "@typescript-eslint/eslint-plugin": "^8.8.1",
diff --git a/packages/utils/src/fetchValidatedJson.test.ts b/packages/utils/src/fetchValidatedJson.test.ts
new file mode 100644
index 000000000..810e7ff46
--- /dev/null
+++ b/packages/utils/src/fetchValidatedJson.test.ts
@@ -0,0 +1,42 @@
+import { object, string } from '@metamask/superstruct';
+import { fetchMock } from '@ocap/test-utils';
+import { describe, it, expect } from 'vitest';
+
+import { fetchValidatedJson } from './fetchValidatedJson.js';
+
+describe('fetchValidatedJson', () => {
+  const TestConfigStruct = object({
+    name: string(),
+  });
+
+  it('fetches and validates JSON successfully', async () => {
+    const mockConfig = {
+      name: 'test',
+    };
+
+    fetchMock.mockResponseOnce(JSON.stringify(mockConfig));
+
+    const result = await fetchValidatedJson(
+      'http://test.url',
+      TestConfigStruct,
+    );
+    expect(result).toStrictEqual(mockConfig);
+    expect(fetchMock).toHaveBeenCalledWith('http://test.url');
+  });
+
+  it('throws on fetch failure', async () => {
+    fetchMock.mockResponseOnce('', { status: 404, statusText: 'Not Found' });
+
+    await expect(
+      fetchValidatedJson('http://test.url', TestConfigStruct),
+    ).rejects.toThrow('Failed to fetch config: 404 Not Found');
+  });
+
+  it('throws on invalid JSON', async () => {
+    fetchMock.mockResponseOnce(JSON.stringify({ invalid: 'config' }));
+
+    await expect(
+      fetchValidatedJson('http://test.url', TestConfigStruct),
+    ).rejects.toThrow('Failed to load config from http://test.url');
+  });
+});
diff --git a/packages/utils/src/fetchValidatedJson.ts b/packages/utils/src/fetchValidatedJson.ts
new file mode 100644
index 000000000..386ac0df6
--- /dev/null
+++ b/packages/utils/src/fetchValidatedJson.ts
@@ -0,0 +1,30 @@
+import type { Struct } from '@metamask/superstruct';
+import { assert } from '@metamask/superstruct';
+
+/**
+ * Load and validate a JSON file
+ *
+ * @param configUrl - Path to the JSON file
+ * @param validator - The validator to use to validate the JSON
+ * @returns The validated JSON
+ */
+export async function fetchValidatedJson<Type>(
+  configUrl: string,
+  validator: Struct<Type>,
+): Promise<Type> {
+  try {
+    const response = await fetch(configUrl);
+    if (!response.ok) {
+      throw new Error(
+        `Failed to fetch config: ${response.status} ${response.statusText}`,
+      );
+    }
+    const config = await response.json();
+    assert(config, validator);
+    return config;
+  } catch (error) {
+    throw new Error(
+      `Failed to load config from ${configUrl}: ${String(error)}`,
+    );
+  }
+}
diff --git a/packages/utils/src/index.ts b/packages/utils/src/index.ts
index 51645be7e..e095864f3 100644
--- a/packages/utils/src/index.ts
+++ b/packages/utils/src/index.ts
@@ -4,3 +4,4 @@ export { delay, makeCounter } from './misc.js';
 export { stringify } from './stringify.js';
 export type { TypeGuard, ExtractGuardType } from './types.js';
 export { isPrimitive, isTypedArray, isTypedObject } from './types.js';
+export { fetchValidatedJson } from './fetchValidatedJson.js';
diff --git a/vitest.config.ts b/vitest.config.ts
index 0f821a70f..768cc3766 100644
--- a/vitest.config.ts
+++ b/vitest.config.ts
@@ -68,16 +68,16 @@ export default defineConfig({
           lines: 100,
         },
         'packages/extension/**': {
-          statements: 71.68,
-          functions: 75.95,
-          branches: 71.12,
-          lines: 71.71,
+          statements: 74.01,
+          functions: 78.97,
+          branches: 71.81,
+          lines: 74.05,
         },
         'packages/kernel/**': {
-          statements: 44.48,
-          functions: 54.72,
-          branches: 30.46,
-          lines: 44.71,
+          statements: 48.85,
+          functions: 60,
+          branches: 36.97,
+          lines: 49.1,
         },
         'packages/nodejs/**': {
           statements: 46.75,
diff --git a/yarn.lock b/yarn.lock
index b0de7f3da..8c07c9c02 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -2421,6 +2421,7 @@ __metadata:
     "@metamask/eslint-config": "npm:^14.0.0"
     "@metamask/eslint-config-nodejs": "npm:^14.0.0"
     "@metamask/eslint-config-typescript": "npm:^14.0.0"
+    "@metamask/superstruct": "npm:^3.1.0"
     "@ocap/cli": "workspace:^"
     "@typescript-eslint/eslint-plugin": "npm:^8.8.1"
     "@typescript-eslint/parser": "npm:^8.8.1"
@@ -2454,9 +2455,11 @@ __metadata:
     "@metamask/eslint-config": "npm:^14.0.0"
     "@metamask/eslint-config-nodejs": "npm:^14.0.0"
     "@metamask/eslint-config-typescript": "npm:^14.0.0"
+    "@metamask/superstruct": "npm:^3.1.0"
     "@metamask/utils": "npm:^11.0.1"
     "@ocap/cli": "workspace:^"
     "@ocap/errors": "workspace:^"
+    "@ocap/test-utils": "workspace:^"
     "@ts-bridge/cli": "npm:^0.6.2"
     "@ts-bridge/shims": "npm:^0.1.1"
     "@typescript-eslint/eslint-plugin": "npm:^8.8.1"