diff --git a/src/assets/__tests__/__snapshots__/assets.snapshot.test.ts.snap b/src/assets/__tests__/__snapshots__/assets.snapshot.test.ts.snap
index 0e2f5950..8a5594ab 100644
--- a/src/assets/__tests__/__snapshots__/assets.snapshot.test.ts.snap
+++ b/src/assets/__tests__/__snapshots__/assets.snapshot.test.ts.snap
@@ -1012,6 +1012,15 @@ exports[`Assets Directory Snapshots > Python framework assets > python/python/au
 
 exports[`Assets Directory Snapshots > Python framework assets > python/python/autogen/base/mcp_client/client.py should match snapshot 1`] = `
 "from typing import List
+{{#if isVpc}}
+# VPC mode: external MCP endpoints are not reachable without a NAT gateway.
+# Add an AgentCore Gateway with \`agentcore add gateway\`, or configure your own endpoint below.
+
+
+async def get_streamable_http_mcp_tools() -> List:
+    """No MCP server configured. Add a gateway with \`agentcore add gateway\`."""
+    return []
+{{else}}
 from autogen_ext.tools.mcp import (
     StreamableHttpMcpToolAdapter,
     StreamableHttpServerParams,
@@ -1029,6 +1038,7 @@ async def get_streamable_http_mcp_tools() -> List[StreamableHttpMcpToolAdapter]:
     # to use an MCP server that supports bearer authentication, add headers={"Authorization": f"Bearer {access_token}"}
     server_params = StreamableHttpServerParams(url=EXAMPLE_MCP_ENDPOINT)
     return await mcp_server_tools(server_params)
+{{/if}}
 "
 `;
 
@@ -1792,6 +1802,14 @@ def get_all_gateway_mcp_toolsets() -> list[MCPToolset]:
     {{/each}}
     return toolsets
 {{else}}
+{{#if isVpc}}
+# VPC mode: external MCP endpoints are not reachable without a NAT gateway.
+# Add an AgentCore Gateway with \`agentcore add gateway\`, or configure your own endpoint below.
+
+def get_streamable_http_mcp_client() -> MCPToolset | None:
+    """No MCP server configured. Add a gateway with \`agentcore add gateway\`."""
+    return None
+{{else}}
 # ExaAI provides information about code through web searches, crawling and code context searches through their platform. Requires no authentication
 EXAMPLE_MCP_ENDPOINT = "https://mcp.exa.ai/mcp"
 
@@ -1803,6 +1821,7 @@ def get_streamable_http_mcp_client() -> MCPToolset:
         connection_params=StreamableHTTPConnectionParams(url=EXAMPLE_MCP_ENDPOINT)
     )
 {{/if}}
+{{/if}}
 "
 `;
 
@@ -2098,6 +2117,14 @@ def get_all_gateway_mcp_client() -> MultiServerMCPClient | None:
         return None
     return MultiServerMCPClient(servers)
 {{else}}
+{{#if isVpc}}
+# VPC mode: external MCP endpoints are not reachable without a NAT gateway.
+# Add an AgentCore Gateway with \`agentcore add gateway\`, or configure your own endpoint below.
+
+def get_streamable_http_mcp_client() -> MultiServerMCPClient | None:
+    """No MCP server configured. Add a gateway with \`agentcore add gateway\`."""
+    return None
+{{else}}
 # ExaAI provides information about code through web searches, crawling and code context searches through their platform. Requires no authentication
 EXAMPLE_MCP_ENDPOINT = "https://mcp.exa.ai/mcp"
 
@@ -2114,6 +2141,7 @@ def get_streamable_http_mcp_client() -> MultiServerMCPClient:
         }
     )
 {{/if}}
+{{/if}}
 "
 `;
 
@@ -2545,6 +2573,14 @@ def get_all_gateway_mcp_servers() -> list[MCPServerStreamableHttp]:
     {{/each}}
     return servers
 {{else}}
+{{#if isVpc}}
+# VPC mode: external MCP endpoints are not reachable without a NAT gateway.
+# Add an AgentCore Gateway with \`agentcore add gateway\`, or configure your own endpoint below.
+
+def get_streamable_http_mcp_client() -> MCPServerStreamableHttp | None:
+    """No MCP server configured. Add a gateway with \`agentcore add gateway\`."""
+    return None
+{{else}}
 # ExaAI provides information about code through web searches, crawling and code context searches through their platform. Requires no authentication
 EXAMPLE_MCP_ENDPOINT = "https://mcp.exa.ai/mcp"
 
@@ -2556,6 +2592,7 @@ def get_streamable_http_mcp_client() -> MCPServerStreamableHttp:
         name="AgentCore Gateway MCP", params={"url": EXAMPLE_MCP_ENDPOINT}
     )
 {{/if}}
+{{/if}}
 "
 `;
 
@@ -2879,6 +2916,14 @@ def get_all_gateway_mcp_clients() -> list[MCPClient]:
     {{/each}}
     return clients
 {{else}}
+{{#if isVpc}}
+# VPC mode: external MCP endpoints are not reachable without a NAT gateway.
+# Add an AgentCore Gateway with \`agentcore add gateway\`, or configure your own endpoint below.
+
+def get_streamable_http_mcp_client() -> MCPClient | None:
+    """No MCP server configured. Add a gateway with \`agentcore add gateway\`."""
+    return None
+{{else}}
 # ExaAI provides information about code through web searches, crawling and code context searches through their platform. Requires no authentication
 EXAMPLE_MCP_ENDPOINT = "https://mcp.exa.ai/mcp"
 
@@ -2887,6 +2932,7 @@ def get_streamable_http_mcp_client() -> MCPClient:
     # to use an MCP server that supports bearer authentication, add headers={"Authorization": f"Bearer {access_token}"}
     return MCPClient(lambda: streamablehttp_client(EXAMPLE_MCP_ENDPOINT))
 {{/if}}
+{{/if}}
 "
 `;
 
diff --git a/src/assets/python/autogen/base/mcp_client/client.py b/src/assets/python/autogen/base/mcp_client/client.py
index 7f4c5c3b..4bdc6a93 100644
--- a/src/assets/python/autogen/base/mcp_client/client.py
+++ b/src/assets/python/autogen/base/mcp_client/client.py
@@ -1,4 +1,13 @@
 from typing import List
+{{#if isVpc}}
+# VPC mode: external MCP endpoints are not reachable without a NAT gateway.
+# Add an AgentCore Gateway with `agentcore add gateway`, or configure your own endpoint below.
+
+
+async def get_streamable_http_mcp_tools() -> List:
+    """No MCP server configured. Add a gateway with `agentcore add gateway`."""
+    return []
+{{else}}
 from autogen_ext.tools.mcp import (
     StreamableHttpMcpToolAdapter,
     StreamableHttpServerParams,
@@ -16,3 +25,4 @@ async def get_streamable_http_mcp_tools() -> List[StreamableHttpMcpToolAdapter]:
     # to use an MCP server that supports bearer authentication, add headers={"Authorization": f"Bearer {access_token}"}
     server_params = StreamableHttpServerParams(url=EXAMPLE_MCP_ENDPOINT)
     return await mcp_server_tools(server_params)
+{{/if}}
diff --git a/src/assets/python/googleadk/base/mcp_client/client.py b/src/assets/python/googleadk/base/mcp_client/client.py
index e6dddd62..df9e0512 100644
--- a/src/assets/python/googleadk/base/mcp_client/client.py
+++ b/src/assets/python/googleadk/base/mcp_client/client.py
@@ -53,6 +53,14 @@ def get_all_gateway_mcp_toolsets() -> list[MCPToolset]:
     {{/each}}
     return toolsets
 {{else}}
+{{#if isVpc}}
+# VPC mode: external MCP endpoints are not reachable without a NAT gateway.
+# Add an AgentCore Gateway with `agentcore add gateway`, or configure your own endpoint below.
+
+def get_streamable_http_mcp_client() -> MCPToolset | None:
+    """No MCP server configured. Add a gateway with `agentcore add gateway`."""
+    return None
+{{else}}
 # ExaAI provides information about code through web searches, crawling and code context searches through their platform. Requires no authentication
 EXAMPLE_MCP_ENDPOINT = "https://mcp.exa.ai/mcp"
 
@@ -64,3 +72,4 @@ def get_streamable_http_mcp_client() -> MCPToolset:
         connection_params=StreamableHTTPConnectionParams(url=EXAMPLE_MCP_ENDPOINT)
     )
 {{/if}}
+{{/if}}
diff --git a/src/assets/python/langchain_langgraph/base/mcp_client/client.py b/src/assets/python/langchain_langgraph/base/mcp_client/client.py
index 71b336d2..8fbf92da 100644
--- a/src/assets/python/langchain_langgraph/base/mcp_client/client.py
+++ b/src/assets/python/langchain_langgraph/base/mcp_client/client.py
@@ -50,6 +50,14 @@ def get_all_gateway_mcp_client() -> MultiServerMCPClient | None:
         return None
     return MultiServerMCPClient(servers)
 {{else}}
+{{#if isVpc}}
+# VPC mode: external MCP endpoints are not reachable without a NAT gateway.
+# Add an AgentCore Gateway with `agentcore add gateway`, or configure your own endpoint below.
+
+def get_streamable_http_mcp_client() -> MultiServerMCPClient | None:
+    """No MCP server configured. Add a gateway with `agentcore add gateway`."""
+    return None
+{{else}}
 # ExaAI provides information about code through web searches, crawling and code context searches through their platform. Requires no authentication
 EXAMPLE_MCP_ENDPOINT = "https://mcp.exa.ai/mcp"
 
@@ -66,3 +74,4 @@ def get_streamable_http_mcp_client() -> MultiServerMCPClient:
         }
     )
 {{/if}}
+{{/if}}
diff --git a/src/assets/python/openaiagents/base/mcp_client/client.py b/src/assets/python/openaiagents/base/mcp_client/client.py
index 2fe91136..901fe5fa 100644
--- a/src/assets/python/openaiagents/base/mcp_client/client.py
+++ b/src/assets/python/openaiagents/base/mcp_client/client.py
@@ -52,6 +52,14 @@ def get_all_gateway_mcp_servers() -> list[MCPServerStreamableHttp]:
     {{/each}}
     return servers
 {{else}}
+{{#if isVpc}}
+# VPC mode: external MCP endpoints are not reachable without a NAT gateway.
+# Add an AgentCore Gateway with `agentcore add gateway`, or configure your own endpoint below.
+
+def get_streamable_http_mcp_client() -> MCPServerStreamableHttp | None:
+    """No MCP server configured. Add a gateway with `agentcore add gateway`."""
+    return None
+{{else}}
 # ExaAI provides information about code through web searches, crawling and code context searches through their platform. Requires no authentication
 EXAMPLE_MCP_ENDPOINT = "https://mcp.exa.ai/mcp"
 
@@ -63,3 +71,4 @@ def get_streamable_http_mcp_client() -> MCPServerStreamableHttp:
         name="AgentCore Gateway MCP", params={"url": EXAMPLE_MCP_ENDPOINT}
     )
 {{/if}}
+{{/if}}
diff --git a/src/assets/python/strands/base/mcp_client/client.py b/src/assets/python/strands/base/mcp_client/client.py
index 01457de2..981c806a 100644
--- a/src/assets/python/strands/base/mcp_client/client.py
+++ b/src/assets/python/strands/base/mcp_client/client.py
@@ -54,6 +54,14 @@ def get_all_gateway_mcp_clients() -> list[MCPClient]:
     {{/each}}
     return clients
 {{else}}
+{{#if isVpc}}
+# VPC mode: external MCP endpoints are not reachable without a NAT gateway.
+# Add an AgentCore Gateway with `agentcore add gateway`, or configure your own endpoint below.
+
+def get_streamable_http_mcp_client() -> MCPClient | None:
+    """No MCP server configured. Add a gateway with `agentcore add gateway`."""
+    return None
+{{else}}
 # ExaAI provides information about code through web searches, crawling and code context searches through their platform. Requires no authentication
 EXAMPLE_MCP_ENDPOINT = "https://mcp.exa.ai/mcp"
 
@@ -62,3 +70,4 @@ def get_streamable_http_mcp_client() -> MCPClient:
     # to use an MCP server that supports bearer authentication, add headers={"Authorization": f"Bearer {access_token}"}
     return MCPClient(lambda: streamablehttp_client(EXAMPLE_MCP_ENDPOINT))
 {{/if}}
+{{/if}}
diff --git a/src/cli/commands/add/__tests__/validate.test.ts b/src/cli/commands/add/__tests__/validate.test.ts
index 9a24db86..db453485 100644
--- a/src/cli/commands/add/__tests__/validate.test.ts
+++ b/src/cli/commands/add/__tests__/validate.test.ts
@@ -989,3 +989,80 @@ describe('validate', () => {
     });
   });
 });
+
+describe('validateAddAgentOptions - VPC validation', () => {
+  const baseOptions: AddAgentOptions = {
+    name: 'TestAgent',
+    type: 'byo',
+    language: 'Python',
+    framework: 'Strands',
+    modelProvider: 'Bedrock',
+    build: 'CodeZip',
+    codeLocation: './app/test/',
+  };
+
+  it('accepts valid VPC options', () => {
+    const result = validateAddAgentOptions({
+      ...baseOptions,
+      networkMode: 'VPC',
+      subnets: 'subnet-12345678',
+      securityGroups: 'sg-12345678',
+    });
+    expect(result.valid).toBe(true);
+  });
+
+  it('accepts PUBLIC network mode without VPC options', () => {
+    const result = validateAddAgentOptions({
+      ...baseOptions,
+      networkMode: 'PUBLIC',
+    });
+    expect(result.valid).toBe(true);
+  });
+
+  it('rejects invalid network mode', () => {
+    const result = validateAddAgentOptions({
+      ...baseOptions,
+      networkMode: 'INVALID',
+    });
+    expect(result.valid).toBe(false);
+    expect(result.error).toContain('Invalid network mode');
+  });
+
+  it('rejects VPC mode without subnets', () => {
+    const result = validateAddAgentOptions({
+      ...baseOptions,
+      networkMode: 'VPC',
+      securityGroups: 'sg-12345678',
+    });
+    expect(result.valid).toBe(false);
+    expect(result.error).toContain('--subnets is required');
+  });
+
+  it('rejects VPC mode without security groups', () => {
+    const result = validateAddAgentOptions({
+      ...baseOptions,
+      networkMode: 'VPC',
+      subnets: 'subnet-12345678',
+    });
+    expect(result.valid).toBe(false);
+    expect(result.error).toContain('--security-groups is required');
+  });
+
+  it('rejects subnets without VPC mode', () => {
+    const result = validateAddAgentOptions({
+      ...baseOptions,
+      subnets: 'subnet-12345678',
+    });
+    expect(result.valid).toBe(false);
+    expect(result.error).toContain('only valid with --network-mode VPC');
+  });
+
+  it('rejects security groups without VPC mode', () => {
+    const result = validateAddAgentOptions({
+      ...baseOptions,
+      securityGroups: 'sg-12345678',
+    });
+    expect(result.valid).toBe(false);
+    expect(result.error).toContain('only valid with --network-mode VPC');
+  });
+});
diff --git a/src/cli/commands/add/types.ts b/src/cli/commands/add/types.ts
index 6f39c224..6e0ffab8 100644
--- a/src/cli/commands/add/types.ts
+++ b/src/cli/commands/add/types.ts
@@ -1,8 +1,9 @@
 import type { GatewayAuthorizerType, ModelProvider, SDKFramework, TargetLanguage } from '../../../schema';
 import type { MemoryOption } from '../../tui/screens/generate/types';
+import type { VpcOptions } from '../shared/vpc-utils';
 
 // Agent types
-export interface AddAgentOptions {
+export interface AddAgentOptions extends VpcOptions {
   name?: string;
   type?: 'create' | 'byo';
   build?: string;
diff --git a/src/cli/commands/add/validate.ts b/src/cli/commands/add/validate.ts
index 8c77476d..7ee0c4e8 100644
--- a/src/cli/commands/add/validate.ts
+++ b/src/cli/commands/add/validate.ts
@@ -11,6 +11,7 @@ import {
   getSupportedModelProviders,
   matchEnumValue,
 } from '../../../schema';
+import { validateVpcOptions } from '../shared/vpc-utils';
 import type {
   AddAgentOptions,
   AddGatewayOptions,
@@ -150,6 +151,12 @@ export function validateAddAgentOptions(options: AddAgentOptions): ValidationRes
     }
   }
 
+  // Validate VPC options
+  const vpcResult = validateVpcOptions(options);
+  if (!vpcResult.valid) {
+    return { valid: false, error: vpcResult.error };
+  }
+
   return { valid: true };
 }
 
diff --git a/src/cli/commands/create/__tests__/validate.test.ts b/src/cli/commands/create/__tests__/validate.test.ts
index 8137f5d7..e465d44e 100644
--- a/src/cli/commands/create/__tests__/validate.test.ts
+++ b/src/cli/commands/create/__tests__/validate.test.ts
@@ -165,3 +165,118 @@ describe('validateCreateOptions', () => {
     expect(typeof result.valid).toBe('boolean');
   });
 });
+
+describe('validateCreateOptions - VPC validation', () => {
+  const cwd = join(tmpdir(), `create-vpc-${randomUUID()}`);
+
+  const baseOptions = {
+    name: 'TestProject',
+    language: 'Python',
+    framework: 'Strands',
+    modelProvider: 'Bedrock',
+    memory: 'none',
+  };
+
+  it('accepts valid VPC options', () => {
+    const result = validateCreateOptions(
+      {
+        ...baseOptions,
+        networkMode: 'VPC',
+        subnets: 'subnet-12345678',
+        securityGroups: 'sg-12345678',
+      },
+      cwd
+    );
+    expect(result.valid).toBe(true);
+  });
+
+  it('accepts PUBLIC network mode without VPC options', () => {
+    const result = validateCreateOptions(
+      {
+        ...baseOptions,
+        networkMode: 'PUBLIC',
+      },
+      cwd
+    );
+    expect(result.valid).toBe(true);
+  });
+
+  it('accepts no network mode (defaults to PUBLIC)', () => {
+    const result = validateCreateOptions({ ...baseOptions }, cwd);
+    expect(result.valid).toBe(true);
+  });
+
+  it('rejects invalid network mode', () => {
+    const result = validateCreateOptions(
+      {
+        ...baseOptions,
+        networkMode: 'INVALID',
+      },
+      cwd
+    );
+    expect(result.valid).toBe(false);
+    expect(result.error).toContain('Invalid network mode');
+  });
+
+  it('rejects VPC mode without subnets', () => {
+    const result = validateCreateOptions(
+      {
+        ...baseOptions,
+        networkMode: 'VPC',
+        securityGroups: 'sg-12345678',
+      },
+      cwd
+    );
+    expect(result.valid).toBe(false);
+    expect(result.error).toContain('--subnets is required');
+  });
+
+  it('rejects VPC mode without security groups', () => {
+    const result = validateCreateOptions(
+      {
+        ...baseOptions,
+        networkMode: 'VPC',
+        subnets: 'subnet-12345678',
+      },
+      cwd
+    );
+    expect(result.valid).toBe(false);
+    expect(result.error).toContain('--security-groups is required');
+  });
+
+  it('rejects subnets without VPC mode', () => {
+    const result = validateCreateOptions(
+      {
+        ...baseOptions,
+        subnets: 'subnet-12345678',
+      },
+      cwd
+    );
+    expect(result.valid).toBe(false);
+    expect(result.error).toContain('only valid with --network-mode VPC');
+  });
+
+  it('rejects security groups without VPC mode', () => {
+    const result = validateCreateOptions(
+      {
+        ...baseOptions,
+        securityGroups: 'sg-12345678',
+      },
+      cwd
+    );
+    expect(result.valid).toBe(false);
+    expect(result.error).toContain('only valid with --network-mode VPC');
+  });
+
+  it('rejects VPC mode missing both subnets and security groups', () => {
+    const result = validateCreateOptions(
+      {
+        ...baseOptions,
+        networkMode: 'VPC',
+      },
+      cwd
+    );
+    expect(result.valid).toBe(false);
+    expect(result.error).toContain('--subnets is required');
+  });
+});
diff --git a/src/cli/commands/create/action.ts b/src/cli/commands/create/action.ts
index c99f69dc..ac1c06fa 100644
--- a/src/cli/commands/create/action.ts
+++ b/src/cli/commands/create/action.ts
@@ -4,6 +4,7 @@ import type {
   BuildType,
   DeployedState,
   ModelProvider,
+  NetworkMode,
   SDKFramework,
   TargetLanguage,
 } from '../../../schema';
@@ -120,6 +121,9 @@ export interface CreateWithAgentOptions {
   modelProvider: ModelProvider;
   apiKey?: string;
   memory: MemoryOption;
+  networkMode?: NetworkMode;
+  subnets?: string[];
+  securityGroups?: string[];
   skipGit?: boolean;
   skipPythonSetup?: boolean;
   onProgress?: ProgressCallback;
@@ -135,6 +139,9 @@ export async function createProjectWithAgent(options: CreateWithAgentOptions): P
     modelProvider,
     apiKey,
     memory,
+    networkMode,
+    subnets,
+    securityGroups,
     skipGit,
     skipPythonSetup,
     onProgress,
@@ -172,6 +179,9 @@ export async function createProjectWithAgent(options: CreateWithAgentOptions): P
       apiKey,
       memory,
       language,
+      networkMode,
+      subnets,
+      securityGroups,
     };
 
     // Resolve credential strategy FIRST (new project has no existing credentials)
diff --git a/src/cli/commands/create/command.tsx b/src/cli/commands/create/command.tsx
index ada69dd8..eada2793 100644
--- a/src/cli/commands/create/command.tsx
+++ b/src/cli/commands/create/command.tsx
@@ -1,8 +1,9 @@
 import { getWorkingDirectory } from '../../../lib';
-import type { BuildType, ModelProvider, SDKFramework, TargetLanguage } from '../../../schema';
+import type { BuildType, ModelProvider, NetworkMode, SDKFramework, TargetLanguage } from '../../../schema';
 import { getErrorMessage } from '../../errors';
 import { COMMAND_DESCRIPTIONS } from '../../tui/copy';
 import { CreateScreen } from '../../tui/screens/create';
+import { parseCommaSeparatedList } from '../shared/vpc-utils';
 import { type ProgressCallback, createProject, createProjectWithAgent, getDryRunInfo } from './action';
 import type { CreateOptions } from './types';
 import { validateCreateOptions } from './validate';
@@ -120,6 +121,9 @@ async function handleCreateCLI(options: CreateOptions): Promise<void> {
         modelProvider: options.modelProvider as ModelProvider,
         apiKey: options.apiKey,
         memory: options.memory as 'none' | 'shortTerm' | 'longAndShortTerm',
+        networkMode: options.networkMode as NetworkMode | undefined,
+        subnets: parseCommaSeparatedList(options.subnets),
+        securityGroups: parseCommaSeparatedList(options.securityGroups),
         skipGit: options.skipGit,
         skipPythonSetup: options.skipPythonSetup,
         onProgress,
@@ -152,6 +156,9 @@ export const registerCreate = (program: Command) => {
     .option('--model-provider <provider>', 'Model provider (Bedrock, Anthropic, OpenAI, Gemini) [non-interactive]')
     .option('--api-key <key>', 'API key for non-Bedrock providers [non-interactive]')
     .option('--memory <option>', 'Memory option (none, shortTerm, longAndShortTerm) [non-interactive]')
+    .option('--network-mode <mode>', 'Network mode (PUBLIC, VPC) [non-interactive]')
+    .option('--subnets <ids>', 'Comma-separated subnet IDs (required for VPC mode) [non-interactive]')
+    .option('--security-groups <ids>', 'Comma-separated security group IDs (required for VPC mode) [non-interactive]')
     .option('--output-dir <dir>', 'Output directory (default: current directory) [non-interactive]')
     .option('--skip-git', 'Skip git repository initialization [non-interactive]')
     .option('--skip-python-setup', 'Skip Python virtual environment setup [non-interactive]')
diff --git a/src/cli/commands/create/types.ts b/src/cli/commands/create/types.ts
index 44fcd68b..b359450e 100644
--- a/src/cli/commands/create/types.ts
+++ b/src/cli/commands/create/types.ts
@@ -1,4 +1,6 @@
-export interface CreateOptions {
+import type { VpcOptions } from '../shared/vpc-utils';
+
+export interface CreateOptions extends VpcOptions {
   name?: string;
   agent?: boolean;
   defaults?: boolean;
diff --git a/src/cli/commands/create/validate.ts b/src/cli/commands/create/validate.ts
index 6c3725f8..ee497398 100644
--- a/src/cli/commands/create/validate.ts
+++ b/src/cli/commands/create/validate.ts
@@ -7,6 +7,7 @@ import {
   getSupportedModelProviders,
   matchEnumValue,
 } from '../../../schema';
+import { validateVpcOptions } from '../shared/vpc-utils';
 import type { CreateOptions } from './types';
 import { existsSync } from 'fs';
 import { join } from 'path';
@@ -129,5 +130,11 @@ export function validateCreateOptions(options: CreateOptions, cwd?: string): Val
     }
   }
 
+  // Validate VPC options
+  const vpcResult = validateVpcOptions(options);
+  if (!vpcResult.valid) {
+    return { valid: false, error: vpcResult.error };
+  }
+
   return { valid: true };
 }
diff --git a/src/cli/commands/dev/command.tsx b/src/cli/commands/dev/command.tsx
index 374f446e..94aa42a3 100644
--- a/src/cli/commands/dev/command.tsx
+++ b/src/cli/commands/dev/command.tsx
@@ -103,6 +103,14 @@ export const registerDev = (program: Command) => {
           process.exit(1);
         }
 
+        // Warn about VPC mode limitations in local dev
+        const targetDevAgent = opts.agent ? project.agents.find(a => a.name === opts.agent) : project.agents[0];
+        if (targetDevAgent?.networkMode === 'VPC') {
+          console.log(
+            '\x1b[33mWarning: This agent uses VPC network mode. Local dev server runs outside your VPC. Network behavior may differ from deployed environment.\x1b[0m\n'
+          );
+        }
+
         const supportedAgents = getDevSupportedAgents(project);
         if (supportedAgents.length === 0) {
           render(
diff --git a/src/cli/commands/invoke/action.ts b/src/cli/commands/invoke/action.ts
index 089a869c..588c1f29 100644
--- a/src/cli/commands/invoke/action.ts
+++ b/src/cli/commands/invoke/action.ts
@@ -67,6 +67,13 @@ export async function handleInvoke(context: InvokeContext, options: InvokeOption
     return { success: false, error: 'No agents defined in configuration' };
   }
 
+  // Warn about VPC mode endpoint requirements
+  if (agentSpec.networkMode === 'VPC') {
+    console.log(
+      '\x1b[33mWarning: This agent uses VPC network mode. Ensure your VPC endpoints are configured for invocation.\x1b[0m'
+    );
+  }
+
   // Get the deployed state for this specific agent
   const agentState = targetState?.resources?.agents?.[agentSpec.name];
 
diff --git a/src/cli/commands/shared/__tests__/vpc-utils.test.ts b/src/cli/commands/shared/__tests__/vpc-utils.test.ts
new file mode 100644
index 00000000..916d6c42
--- /dev/null
+++ b/src/cli/commands/shared/__tests__/vpc-utils.test.ts
@@ -0,0 +1,112 @@
+import { parseCommaSeparatedList, validateSecurityGroupIds, validateSubnetIds, validateVpcOptions } from '../vpc-utils';
+import { describe, expect, it } from 'vitest';
+
+describe('parseCommaSeparatedList', () => {
+  it('returns undefined for undefined input', () => {
+    expect(parseCommaSeparatedList(undefined)).toBeUndefined();
+  });
+
+  it('returns undefined for empty string', () => {
+    expect(parseCommaSeparatedList('')).toBeUndefined();
+  });
+
+  it('parses comma-separated values and trims whitespace', () => {
+    expect(parseCommaSeparatedList('a, b , c')).toEqual(['a', 'b', 'c']);
+  });
+
+  it('filters out empty entries from trailing commas', () => {
+    expect(parseCommaSeparatedList('a,,b,')).toEqual(['a', 'b']);
+  });
+
+  it('handles a single value', () => {
+    expect(parseCommaSeparatedList('subnet-12345678')).toEqual(['subnet-12345678']);
+  });
+});
+
+describe('validateSubnetIds', () => {
+  it('accepts valid subnet IDs', () => {
+    expect(validateSubnetIds('subnet-12345678')).toBe(true);
+    expect(validateSubnetIds('subnet-12345678, subnet-abcdef12')).toBe(true);
+    expect(validateSubnetIds('subnet-12345678abcdef12')).toBe(true);
+  });
+
+  it('rejects empty input', () => {
+    const result = validateSubnetIds('');
+    expect(result).not.toBe(true);
+    expect(result).toContain('At least one subnet ID is required');
+  });
+
+  it('rejects invalid subnet ID format', () => {
+    const result = validateSubnetIds('vpc-12345678');
+    expect(result).not.toBe(true);
+    expect(result).toContain('Invalid subnet ID format');
+  });
+
+  it('rejects if any ID in the list is invalid', () => {
+    const result = validateSubnetIds('subnet-12345678, bad-id');
+    expect(result).not.toBe(true);
+    expect(result).toContain('Invalid subnet ID format');
+  });
+
+  it('rejects subnet IDs that are too short', () => {
+    const result = validateSubnetIds('subnet-1234');
+    expect(result).not.toBe(true);
+  });
+});
+
+describe('validateSecurityGroupIds', () => {
+  it('accepts valid security group IDs', () => {
+    expect(validateSecurityGroupIds('sg-12345678')).toBe(true);
+    expect(validateSecurityGroupIds('sg-12345678, sg-abcdef12')).toBe(true);
+    expect(validateSecurityGroupIds('sg-12345678abcdef12')).toBe(true);
+  });
+
+  it('rejects empty input', () => {
+    const result = validateSecurityGroupIds('');
+    expect(result).not.toBe(true);
+    expect(result).toContain('At least one security group ID is required');
+  });
+
+  it('rejects invalid security group ID format', () => {
+    const result = validateSecurityGroupIds('subnet-12345678');
+    expect(result).not.toBe(true);
+    expect(result).toContain('Invalid security group ID format');
+  });
+
+  it('rejects if any ID in the list is invalid', () => {
+    const result = validateSecurityGroupIds('sg-12345678, bad-id');
+    expect(result).not.toBe(true);
+    expect(result).toContain('Invalid security group ID format');
+  });
+});
+
+describe('validateVpcOptions - format validation', () => {
+  it('rejects VPC mode with invalid subnet format', () => {
+    const result = validateVpcOptions({
+      networkMode: 'VPC',
+      subnets: 'not-a-subnet',
+      securityGroups: 'sg-12345678',
+    });
+    expect(result.valid).toBe(false);
+    expect(result.error).toContain('Invalid subnet ID format');
+  });
+
+  it('rejects VPC mode with invalid security group format', () => {
+    const result = validateVpcOptions({
+      networkMode: 'VPC',
+      subnets: 'subnet-12345678',
+      securityGroups: 'not-a-sg',
+    });
+    expect(result.valid).toBe(false);
+    expect(result.error).toContain('Invalid security group ID format');
+  });
+
+  it('accepts VPC mode with valid subnet and security group formats', () => {
+    const result = validateVpcOptions({
+      networkMode: 'VPC',
+      subnets: 'subnet-12345678, subnet-abcdef12',
+      securityGroups: 'sg-12345678',
+    });
+    expect(result.valid).toBe(true);
+  });
+});
diff --git a/src/cli/commands/shared/vpc-utils.ts b/src/cli/commands/shared/vpc-utils.ts
new file mode 100644
index 00000000..e38fbe6c
--- /dev/null
+++ b/src/cli/commands/shared/vpc-utils.ts
@@ -0,0 +1,84 @@
+export interface VpcOptions {
+  networkMode?: string;
+  subnets?: string;
+  securityGroups?: string;
+}
+
+export interface VpcValidationResult {
+  valid: boolean;
+  error?: string;
+}
+
+/**
+ * Warning shown when an agent is configured with VPC network mode.
+ * Used in CLI output, TUI completion screens, and exit messages.
+ */
+export const VPC_ENDPOINT_WARNING =
+  'VPC mode may require VPC endpoints for CloudWatch, X-Ray, ECR, and Bedrock depending on your agent configuration. If your agent calls public APIs or uses an API-key-based provider, a NAT gateway or additional endpoints may also be needed.';
+
+const SUBNET_PATTERN = /^subnet-[0-9a-zA-Z]{8,17}$/;
+const SECURITY_GROUP_PATTERN = /^sg-[0-9a-zA-Z]{8,17}$/;
+
+export function parseCommaSeparatedList(value: string | undefined): string[] | undefined {
+  if (!value) return undefined;
+  return value
+    .split(',')
+    .map(s => s.trim())
+    .filter(Boolean);
+}
+
+/**
+ * Validate a comma-separated list of subnet IDs.
+ * Returns true if valid, or an error message string if invalid.
+ */
+export function validateSubnetIds(value: string): true | string {
+  const ids = value
+    .split(',')
+    .map(s => s.trim())
+    .filter(Boolean);
+  if (ids.length === 0) return 'At least one subnet ID is required';
+  const invalid = ids.filter(id => !SUBNET_PATTERN.test(id));
+  if (invalid.length > 0) return `Invalid subnet ID format: ${invalid[0]}. Expected subnet-xxxxxxxx`;
+  return true;
+}
+
+/**
+ * Validate a comma-separated list of security group IDs.
+ * Returns true if valid, or an error message string if invalid.
+ */
+export function validateSecurityGroupIds(value: string): true | string {
+  const ids = value
+    .split(',')
+    .map(s => s.trim())
+    .filter(Boolean);
+  if (ids.length === 0) return 'At least one security group ID is required';
+  const invalid = ids.filter(id => !SECURITY_GROUP_PATTERN.test(id));
+  if (invalid.length > 0) return `Invalid security group ID format: ${invalid[0]}. Expected sg-xxxxxxxx`;
+  return true;
+}
+
+export function validateVpcOptions(options: VpcOptions): VpcValidationResult {
+  if (options.networkMode && options.networkMode !== 'PUBLIC' && options.networkMode !== 'VPC') {
+    return { valid: false, error: `Invalid network mode: ${options.networkMode}. Use PUBLIC or VPC` };
+  }
+
+  if (options.networkMode === 'VPC') {
+    if (!options.subnets) {
+      return { valid: false, error: '--subnets is required when network mode is VPC' };
+    }
+    if (!options.securityGroups) {
+      return { valid: false, error: '--security-groups is required when network mode is VPC' };
+    }
+
+    const subnetResult = validateSubnetIds(options.subnets);
+    if (subnetResult !== true) return { valid: false, error: subnetResult };
+    const sgResult = validateSecurityGroupIds(options.securityGroups);
+    if (sgResult !== true) return { valid: false, error: sgResult };
+  }
+
+  if (options.networkMode !== 'VPC' && (options.subnets || options.securityGroups)) {
+    return { valid: false, error: '--subnets and --security-groups are only valid with --network-mode VPC' };
+  }
+
+  return { valid: true };
+}
diff --git a/src/cli/operations/agent/generate/__tests__/schema-mapper.test.ts b/src/cli/operations/agent/generate/__tests__/schema-mapper.test.ts
index 73d162e4..5fc794e5 100644
--- a/src/cli/operations/agent/generate/__tests__/schema-mapper.test.ts
+++ b/src/cli/operations/agent/generate/__tests__/schema-mapper.test.ts
@@ -1,4 +1,5 @@
 import { computeManagedOAuthCredentialName } from '../../../../primitives/credential-utils.js';
+import { mapByoConfigToAgent } from '../../../../tui/screens/agent/useAddAgent.js';
 import type { GenerateConfig } from '../../../../tui/screens/generate/types.js';
 import {
   mapGenerateConfigToAgent,
@@ -201,3 +202,104 @@ describe('gateway credential provider name mapping', () => {
     expect(computeManagedOAuthCredentialName('test')).toBe('test-oauth');
   });
 });
+
+describe('mapGenerateConfigToAgent - VPC support', () => {
+  const vpcBaseConfig = {
+    projectName: 'TestAgent',
+    buildType: 'CodeZip' as const,
+    sdk: 'Strands' as const,
+    modelProvider: 'Bedrock' as const,
+    memory: 'none' as const,
+    language: 'Python' as const,
+  };
+
+  it('defaults to PUBLIC network mode when networkMode is absent', () => {
+    const result = mapGenerateConfigToAgent(vpcBaseConfig);
+    expect(result.networkMode).toBe('PUBLIC');
+    expect(result.networkConfig).toBeUndefined();
+  });
+
+  it('uses PUBLIC network mode when explicitly set', () => {
+    const result = mapGenerateConfigToAgent({ ...vpcBaseConfig, networkMode: 'PUBLIC' });
+    expect(result.networkMode).toBe('PUBLIC');
+    expect(result.networkConfig).toBeUndefined();
+  });
+
+  it('produces networkConfig for VPC mode with subnets and security groups', () => {
+    const result = mapGenerateConfigToAgent({
+      ...vpcBaseConfig,
+      networkMode: 'VPC',
+      subnets: ['subnet-12345678', 'subnet-abcdef12'],
+      securityGroups: ['sg-12345678'],
+    });
+    expect(result.networkMode).toBe('VPC');
+    expect(result.networkConfig).toEqual({
+      subnets: ['subnet-12345678', 'subnet-abcdef12'],
+      securityGroups: ['sg-12345678'],
+    });
+  });
+
+  it('does not produce networkConfig for VPC mode without subnets', () => {
+    const result = mapGenerateConfigToAgent({
+      ...vpcBaseConfig,
+      networkMode: 'VPC',
+    });
+    expect(result.networkMode).toBe('VPC');
+    expect(result.networkConfig).toBeUndefined();
+  });
+});
+
+describe('mapByoConfigToAgent - VPC support', () => {
+  const baseByoConfig = {
+    name: 'MyByo',
+    agentType: 'byo' as const,
+    codeLocation: 'app/MyByo/',
+    entrypoint: 'main.py',
+    language: 'Python' as const,
+    buildType: 'CodeZip' as const,
+    framework: 'Strands' as const,
+    modelProvider: 'Bedrock' as const,
+    pythonVersion: 'PYTHON_3_12' as const,
+    memory: 'none' as const,
+  };
+
+  it('defaults to PUBLIC network mode when networkMode is undefined', () => {
+    const result = mapByoConfigToAgent(baseByoConfig);
+    expect(result.networkMode).toBe('PUBLIC');
+    expect(result.networkConfig).toBeUndefined();
+  });
+
+  it('produces networkConfig for VPC mode with subnets and security groups', () => {
+    const result = mapByoConfigToAgent({
+      ...baseByoConfig,
+      networkMode: 'VPC',
+      subnets: ['subnet-12345678'],
+      securityGroups: ['sg-abcdef12'],
+    });
+    expect(result.networkMode).toBe('VPC');
+    expect(result.networkConfig).toEqual({
+      subnets: ['subnet-12345678'],
+      securityGroups: ['sg-abcdef12'],
+    });
+  });
+
+  it('does not produce networkConfig for VPC mode without subnets', () => {
+    const result = mapByoConfigToAgent({
+      ...baseByoConfig,
+      networkMode: 'VPC',
+    });
+    expect(result.networkMode).toBe('VPC');
+    expect(result.networkConfig).toBeUndefined();
+  });
+
+  it('does not produce networkConfig for PUBLIC mode even with subnets', () => {
+    const result = mapByoConfigToAgent({
+      ...baseByoConfig,
+      networkMode: 'PUBLIC',
+      subnets: ['subnet-12345678'],
+      securityGroups: ['sg-abcdef12'],
+    });
+    expect(result.networkMode).toBe('PUBLIC');
+    expect(result.networkConfig).toBeUndefined();
+  });
+});
diff --git a/src/cli/operations/agent/generate/schema-mapper.ts b/src/cli/operations/agent/generate/schema-mapper.ts
index 0b90c71c..26fa912c 100644
--- a/src/cli/operations/agent/generate/schema-mapper.ts
+++ b/src/cli/operations/agent/generate/schema-mapper.ts
@@ -108,6 +108,7 @@ export function mapModelProviderToCredentials(modelProvider: ModelProvider, proj
  */
 export function mapGenerateConfigToAgent(config: GenerateConfig): AgentEnvSpec {
   const codeLocation = `${APP_DIR}/${config.projectName}/`;
+  const networkMode = config.networkMode ?? DEFAULT_NETWORK_MODE;
 
   return {
     type: 'AgentCoreRuntime',
@@ -116,7 +117,15 @@ export function mapGenerateConfigToAgent(config: GenerateConfig): AgentEnvSpec {
     entrypoint: DEFAULT_PYTHON_ENTRYPOINT as FilePath,
     codeLocation: codeLocation as DirectoryPath,
     runtimeVersion: DEFAULT_PYTHON_VERSION,
-    networkMode: DEFAULT_NETWORK_MODE,
+    networkMode,
+    ...(networkMode === 'VPC' &&
+      config.subnets &&
+      config.securityGroups && {
+        networkConfig: {
+          subnets: config.subnets,
+          securityGroups: config.securityGroups,
+        },
+      }),
     modelProvider: config.modelProvider,
   };
 }
@@ -242,6 +251,7 @@ export async function mapGenerateConfigToRenderConfig(
     hasMemory: config.memory !== 'none',
     hasIdentity: identityProviders.length > 0,
     hasGateway: gatewayProviders.length > 0,
+    isVpc: config.networkMode === 'VPC',
     buildType: config.buildType,
     memoryProviders: mapMemoryOptionToMemoryProviders(config.memory, config.projectName),
     identityProviders,
diff --git a/src/cli/primitives/AgentPrimitive.tsx b/src/cli/primitives/AgentPrimitive.tsx
index 8bb9439e..170444d0 100644
--- a/src/cli/primitives/AgentPrimitive.tsx
+++ b/src/cli/primitives/AgentPrimitive.tsx
@@ -5,12 +5,15 @@ import type {
   DirectoryPath,
   FilePath,
   ModelProvider,
+  NetworkMode,
   SDKFramework,
   TargetLanguage,
 } from '../../schema';
 import { AgentEnvSpecSchema, CREDENTIAL_PROVIDERS } from '../../schema';
 import type { AddAgentOptions as CLIAddAgentOptions } from '../commands/add/types';
 import { validateAddAgentOptions } from '../commands/add/validate';
+import type { VpcOptions } from '../commands/shared/vpc-utils';
+import { VPC_ENDPOINT_WARNING, parseCommaSeparatedList } from '../commands/shared/vpc-utils';
 import { getErrorMessage } from '../errors';
 import {
   mapGenerateConfigToRenderConfig,
@@ -33,7 +36,7 @@ import { dirname, join } from 'path';
 /**
  * Options for adding an agent resource.
  */
-export interface AddAgentOptions {
+export interface AddAgentOptions extends VpcOptions {
   name: string;
   type: 'create' | 'byo';
   buildType: BuildType;
@@ -175,6 +178,9 @@ export class AgentPrimitive extends BasePrimitive<AddAgentOptions, RemovableReso
       .option('--memory <mem>', 'Memory: none, shortTerm, longAndShortTerm (create path only) [non-interactive]')
       .option('--code-location <path>', 'Path to existing code (BYO path only) [non-interactive]')
       .option('--entrypoint <file>', 'Entry file relative to code-location (BYO, default: main.py) [non-interactive]')
+      .option('--network-mode <mode>', 'Network mode (PUBLIC, VPC) [non-interactive]')
+      .option('--subnets <ids>', 'Comma-separated subnet IDs (required for VPC mode) [non-interactive]')
+      .option('--security-groups <ids>', 'Comma-separated security group IDs (required for VPC mode) [non-interactive]')
       .option('--json', 'Output as JSON [non-interactive]')
       .action(async options => {
         if (!findConfigRoot()) {
@@ -205,6 +211,9 @@ export class AgentPrimitive extends BasePrimitive<AddAgentOptions, RemovableReso
             modelProvider: cliOptions.modelProvider!,
             apiKey: cliOptions.apiKey,
             memory: cliOptions.memory,
+            networkMode: cliOptions.networkMode,
+            subnets: cliOptions.subnets,
+            securityGroups: cliOptions.securityGroups,
             codeLocation: cliOptions.codeLocation,
             entrypoint: cliOptions.entrypoint,
           });
@@ -216,6 +225,9 @@ export class AgentPrimitive extends BasePrimitive<AddAgentOptions, RemovableReso
             if (result.agentPath) {
               console.log(`Agent code: ${result.agentPath}`);
             }
+            if (cliOptions.networkMode === 'VPC') {
+              console.log(`\x1b[33mNote: ${VPC_ENDPOINT_WARNING}\x1b[0m`);
+            }
           } else {
             console.error(result.error);
           }
@@ -266,6 +278,9 @@ export class AgentPrimitive extends BasePrimitive<AddAgentOptions, RemovableReso
       modelProvider: options.modelProvider,
       memory: options.memory!,
       language: options.language,
+      networkMode: options.networkMode as NetworkMode | undefined,
+      subnets: parseCommaSeparatedList(options.subnets),
+      securityGroups: parseCommaSeparatedList(options.securityGroups),
     };
 
     const agentPath = join(projectRoot, APP_DIR, options.name);
@@ -334,6 +349,10 @@ export class AgentPrimitive extends BasePrimitive<AddAgentOptions, RemovableReso
 
     const project = await configIO.readProjectSpec();
 
+    const networkMode = (options.networkMode as NetworkMode | undefined) ?? 'PUBLIC';
+    const subnets = parseCommaSeparatedList(options.subnets);
+    const securityGroups = parseCommaSeparatedList(options.securityGroups);
+
     const agent: AgentEnvSpec = {
       type: 'AgentCoreRuntime',
       name: options.name,
@@ -341,6 +360,12 @@ export class AgentPrimitive extends BasePrimitive<AddAgentOptions, RemovableReso
       entrypoint: (options.entrypoint ?? 'main.py') as FilePath,
       codeLocation: codeLocation as DirectoryPath,
       runtimeVersion: 'PYTHON_3_12',
+      networkMode,
+      ...(networkMode === 'VPC' &&
+        subnets &&
+        securityGroups && {
+          networkConfig: { subnets, securityGroups },
+        }),
     };
 
     project.agents.push(agent);
diff --git a/src/cli/templates/types.ts b/src/cli/templates/types.ts
index c9366def..8a451753 100644
--- a/src/cli/templates/types.ts
+++ b/src/cli/templates/types.ts
@@ -45,6 +45,8 @@ export interface AgentRenderConfig {
   hasMemory: boolean;
   hasIdentity: boolean;
   hasGateway: boolean;
+  /** Whether agent is deployed in VPC mode (affects example MCP endpoints) */
+  isVpc: boolean;
   /** Build type: CodeZip (default) or Container */
   buildType?: BuildType;
   /** Memory providers for template rendering */
diff --git a/src/cli/tui/screens/add/AddFlow.tsx b/src/cli/tui/screens/add/AddFlow.tsx
index 690d25af..d3f72e23 100644
--- a/src/cli/tui/screens/add/AddFlow.tsx
+++ b/src/cli/tui/screens/add/AddFlow.tsx
@@ -1,4 +1,5 @@
 import { DEFAULT_MODEL_IDS } from '../../../../schema';
+import { VPC_ENDPOINT_WARNING } from '../../../commands/shared/vpc-utils';
 import { computeDefaultCredentialEnvVarName } from '../../../primitives/credential-utils';
 import { ErrorPrompt } from '../../components';
 import { useAvailableAgents } from '../../hooks/useCreateMcp';
@@ -125,6 +126,11 @@ function AgentAddedSummary({
           </Text>
         </Box>
       )}
+      {config.networkMode === 'VPC' && (
+        <Box flexDirection="column" marginTop={1}>
+          <Text color="yellow">Note: {VPC_ENDPOINT_WARNING}</Text>
+        </Box>
+      )}
     </Box>
   );
 }
diff --git a/src/cli/tui/screens/agent/AddAgentScreen.tsx b/src/cli/tui/screens/agent/AddAgentScreen.tsx
index e17a04b0..5ba46dbd 100644
--- a/src/cli/tui/screens/agent/AddAgentScreen.tsx
+++ b/src/cli/tui/screens/agent/AddAgentScreen.tsx
@@ -1,6 +1,11 @@
 import { APP_DIR, ConfigIO } from '../../../../lib';
-import type { ModelProvider } from '../../../../schema';
+import type { ModelProvider, NetworkMode } from '../../../../schema';
 import { AgentNameSchema, DEFAULT_MODEL_IDS } from '../../../../schema';
+import {
+  parseCommaSeparatedList,
+  validateSecurityGroupIds,
+  validateSubnetIds,
+} from '../../../commands/shared/vpc-utils';
 import { computeDefaultCredentialEnvVarName } from '../../../primitives/credential-utils';
 import {
   ApiKeySecretInput,
@@ -25,6 +30,7 @@ import {
   DEFAULT_ENTRYPOINT,
   DEFAULT_PYTHON_VERSION,
   MODEL_PROVIDER_OPTIONS,
+  NETWORK_MODE_OPTIONS,
 } from './types';
 import { Box, Text, useInput } from 'ink';
 import React, { useCallback, useEffect, useMemo, useState } from 'react';
@@ -52,10 +58,27 @@ interface AddAgentScreenProps {
 // Steps for the initial phase (before branching to create or byo)
 type InitialStep = 'name' | 'agentType';
 // Steps for BYO path only (no framework/language - user's code already has these baked in)
-type ByoStep = 'codeLocation' | 'buildType' | 'modelProvider' | 'apiKey' | 'confirm';
+type ByoStep =
+  | 'codeLocation'
+  | 'buildType'
+  | 'modelProvider'
+  | 'apiKey'
+  | 'networkMode'
+  | 'subnets'
+  | 'securityGroups'
+  | 'confirm';
 
 const INITIAL_STEPS: InitialStep[] = ['name', 'agentType'];
-const BYO_STEPS: ByoStep[] = ['codeLocation', 'buildType', 'modelProvider', 'apiKey', 'confirm'];
+const BYO_STEPS: ByoStep[] = [
+  'codeLocation',
+  'buildType',
+  'modelProvider',
+  'apiKey',
+  'networkMode',
+  'subnets',
+  'securityGroups',
+  'confirm',
+];
 
 export function AddAgentScreen({ existingAgentNames, onComplete, onExit }: AddAgentScreenProps) {
   // Phase 1: name + agentType selection
@@ -75,6 +98,9 @@ export function AddAgentScreen({ existingAgentNames, onComplete, onExit }: AddAg
     buildType: 'CodeZip' as BuildType,
     modelProvider: 'Bedrock' as ModelProvider,
     apiKey: undefined as string | undefined,
+    networkMode: 'PUBLIC' as NetworkMode,
+    subnets: '' as string,
+    securityGroups: '' as string,
   });
 
   const { project } = useProject();
@@ -154,6 +180,9 @@ export function AddAgentScreen({ existingAgentNames, onComplete, onExit }: AddAg
       framework: generateWizard.config.sdk,
       modelProvider: generateWizard.config.modelProvider,
       apiKey: generateWizard.config.apiKey,
+      networkMode: generateWizard.config.networkMode,
+      subnets: generateWizard.config.networkMode === 'VPC' ? generateWizard.config.subnets : undefined,
+      securityGroups: generateWizard.config.networkMode === 'VPC' ? generateWizard.config.securityGroups : undefined,
       pythonVersion: DEFAULT_PYTHON_VERSION,
       memory: generateWizard.config.memory,
     };
@@ -174,13 +203,17 @@ export function AddAgentScreen({ existingAgentNames, onComplete, onExit }: AddAg
   // BYO Path
   // ─────────────────────────────────────────────────────────────────────────────
 
-  // BYO steps filtering (remove apiKey for Bedrock)
+  // BYO steps filtering (remove apiKey for Bedrock, subnets/securityGroups for non-VPC)
   const byoSteps = useMemo(() => {
+    let steps = [...BYO_STEPS];
     if (byoConfig.modelProvider === 'Bedrock') {
-      return BYO_STEPS.filter(s => s !== 'apiKey');
+      steps = steps.filter(s => s !== 'apiKey');
+    }
+    if (byoConfig.networkMode !== 'VPC') {
+      steps = steps.filter(s => s !== 'subnets' && s !== 'securityGroups');
     }
-    return BYO_STEPS;
-  }, [byoConfig.modelProvider]);
+    return steps;
+  }, [byoConfig.modelProvider, byoConfig.networkMode]);
 
   const byoCurrentIndex = byoSteps.indexOf(byoStep);
 
@@ -230,6 +263,9 @@ export function AddAgentScreen({ existingAgentNames, onComplete, onExit }: AddAg
       framework: 'Strands', // Default - not used for BYO agents
       modelProvider: byoConfig.modelProvider,
       apiKey: byoConfig.apiKey,
+      networkMode: byoConfig.networkMode,
+      subnets: byoConfig.networkMode === 'VPC' ? parseCommaSeparatedList(byoConfig.subnets) : undefined,
+      securityGroups: byoConfig.networkMode === 'VPC' ? parseCommaSeparatedList(byoConfig.securityGroups) : undefined,
       pythonVersion: DEFAULT_PYTHON_VERSION,
       memory: 'none',
     };
@@ -254,13 +290,39 @@ export function AddAgentScreen({ existingAgentNames, onComplete, onExit }: AddAg
       if (provider !== 'Bedrock') {
         setByoStep('apiKey');
       } else {
-        setByoStep('confirm');
+        setByoStep('networkMode');
       }
     },
     onExit: handleByoBack,
     isActive: isByoPath && byoStep === 'modelProvider',
   });
 
+  // Network mode options for BYO path
+  const networkModeItems: SelectableItem[] = useMemo(
+    () =>
+      NETWORK_MODE_OPTIONS.map(o => ({
+        id: o.id,
+        title: o.title,
+        description: o.description,
+      })),
+    []
+  );
+
+  const networkModeNav = useListNavigation({
+    items: networkModeItems,
+    onSelect: item => {
+      const mode = item.id as NetworkMode;
+      setByoConfig(c => ({ ...c, networkMode: mode }));
+      if (mode === 'VPC') {
+        setByoStep('subnets');
+      } else {
+        setByoStep('confirm');
+      }
+    },
+    onExit: handleByoBack,
+    isActive: isByoPath && byoStep === 'networkMode',
+  });
+
   useListNavigation({
     items: [{ id: 'confirm', title: 'Confirm' }],
     onSelect: handleByoComplete,
@@ -281,7 +343,7 @@ export function AddAgentScreen({ existingAgentNames, onComplete, onExit }: AddAg
       return getWizardHelpText(generateWizard.step);
     }
     // BYO path
-    if (byoStep === 'codeLocation' || byoStep === 'apiKey') {
+    if (byoStep === 'codeLocation' || byoStep === 'apiKey' || byoStep === 'subnets' || byoStep === 'securityGroups') {
       return HELP_TEXT.TEXT_INPUT;
     }
     if (byoStep === 'confirm') {
@@ -413,9 +475,43 @@ export function AddAgentScreen({ existingAgentNames, onComplete, onExit }: AddAg
             envVarName={getProviderInfo(byoConfig.modelProvider).envVarName}
             onSubmit={apiKey => {
               setByoConfig(c => ({ ...c, apiKey }));
+              setByoStep('networkMode');
+            }}
+            onSkip={() => setByoStep('networkMode')}
+            onCancel={handleByoBack}
+          />
+        )}
+
+        {byoStep === 'networkMode' && (
+          <WizardSelect
+            title="Select network mode"
+            items={networkModeItems}
+            selectedIndex={networkModeNav.selectedIndex}
+          />
+        )}
+
+        {byoStep === 'subnets' && (
+          <TextInput
+            prompt="Subnet IDs (comma-separated)"
+            initialValue={byoConfig.subnets}
+            customValidation={validateSubnetIds}
+            onSubmit={value => {
+              setByoConfig(c => ({ ...c, subnets: value }));
+              setByoStep('securityGroups');
+            }}
+            onCancel={handleByoBack}
+          />
+        )}
+
+        {byoStep === 'securityGroups' && (
+          <TextInput
+            prompt="Security group IDs (comma-separated)"
+            initialValue={byoConfig.securityGroups}
+            customValidation={validateSecurityGroupIds}
+            onSubmit={value => {
+              setByoConfig(c => ({ ...c, securityGroups: value }));
               setByoStep('confirm');
             }}
-            onSkip={() => setByoStep('confirm')}
             onCancel={handleByoBack}
           />
         )}
@@ -450,6 +546,13 @@ export function AddAgentScreen({ existingAgentNames, onComplete, onExit }: AddAg
                     },
                   ]
                 : []),
+              { label: 'Network Mode', value: byoConfig.networkMode },
+              ...(byoConfig.networkMode === 'VPC'
+                ? [
+                    { label: 'Subnets', value: byoConfig.subnets || '(none)' },
+                    { label: 'Security Groups', value: byoConfig.securityGroups || '(none)' },
+                  ]
+                : []),
             ]}
           />
         )}
diff --git a/src/cli/tui/screens/agent/types.ts b/src/cli/tui/screens/agent/types.ts
index 48a38d0b..a4bf523c 100644
--- a/src/cli/tui/screens/agent/types.ts
+++ b/src/cli/tui/screens/agent/types.ts
@@ -1,4 +1,11 @@
-import type { BuildType, ModelProvider, PythonRuntime, SDKFramework, TargetLanguage } from '../../../../schema';
+import type {
+  BuildType,
+  ModelProvider,
+  NetworkMode,
+  PythonRuntime,
+  SDKFramework,
+  TargetLanguage,
+} from '../../../../schema';
 import { DEFAULT_MODEL_IDS, getSupportedModelProviders } from '../../../../schema';
 import type { MemoryOption } from '../generate/types';
 
@@ -34,6 +41,9 @@ export type AddAgentStep =
   | 'framework'
   | 'modelProvider'
   | 'apiKey'
+  | 'networkMode'
+  | 'subnets'
+  | 'securityGroups'
   | 'memory'
   | 'confirm';
 
@@ -50,6 +60,12 @@ export interface AddAgentConfig {
   modelProvider: ModelProvider;
   /** API key for non-Bedrock model providers (optional - can be added later) */
   apiKey?: string;
+  /** Network mode for the runtime */
+  networkMode?: NetworkMode;
+  /** Subnet IDs for VPC mode */
+  subnets?: string[];
+  /** Security group IDs for VPC mode */
+  securityGroups?: string[];
   /** Python version (only for Python agents) */
   pythonVersion: PythonRuntime;
   /** Memory option (create path only) */
@@ -65,6 +81,9 @@ export const ADD_AGENT_STEP_LABELS: Record<AddAgentStep, string> = {
   framework: 'Framework',
   modelProvider: 'Model',
   apiKey: 'API Key',
+  networkMode: 'Network',
+  subnets: 'Subnets',
+  securityGroups: 'Security Groups',
   memory: 'Memory',
   confirm: 'Confirm',
 };
@@ -114,5 +133,10 @@ export function getModelProviderOptionsForSdk(sdk: SDKFramework) {
 // Defaults
 // ─────────────────────────────────────────────────────────────────────────────
 
+export const NETWORK_MODE_OPTIONS = [
+  { id: 'PUBLIC', title: 'Public', description: undefined },
+  { id: 'VPC', title: 'VPC', description: 'Attach to your VPC' },
+] as const;
+
 export const DEFAULT_PYTHON_VERSION: PythonRuntime = 'PYTHON_3_12';
 export const DEFAULT_ENTRYPOINT = 'main.py';
diff --git a/src/cli/tui/screens/agent/useAddAgent.ts b/src/cli/tui/screens/agent/useAddAgent.ts
index 46b03903..8df6f4b0 100644
--- a/src/cli/tui/screens/agent/useAddAgent.ts
+++ b/src/cli/tui/screens/agent/useAddAgent.ts
@@ -52,6 +52,7 @@ export type AddAgentOutcome = AddAgentCreateResult | AddAgentByoResult | AddAgen
  * Maps AddAgentConfig (from BYO wizard) to v2 AgentEnvSpec for schema persistence.
  */
 export function mapByoConfigToAgent(config: AddAgentConfig): AgentEnvSpec {
+  const networkMode = config.networkMode ?? 'PUBLIC';
   return {
     type: 'AgentCoreRuntime',
     name: config.name,
@@ -59,7 +60,15 @@ export function mapByoConfigToAgent(config: AddAgentConfig): AgentEnvSpec {
     entrypoint: config.entrypoint as FilePath,
     codeLocation: config.codeLocation as DirectoryPath,
     runtimeVersion: config.pythonVersion,
-    networkMode: 'PUBLIC',
+    networkMode,
+    ...(networkMode === 'VPC' &&
+      config.subnets &&
+      config.securityGroups && {
+        networkConfig: {
+          subnets: config.subnets,
+          securityGroups: config.securityGroups,
+        },
+      }),
   };
 }
 
@@ -74,6 +83,9 @@ function mapAddAgentConfigToGenerateConfig(config: AddAgentConfig): GenerateConf
     modelProvider: config.modelProvider,
     memory: config.memory,
     language: config.language,
+    networkMode: config.networkMode,
+    subnets: config.subnets,
+    securityGroups: config.securityGroups,
   };
 }
 
diff --git a/src/cli/tui/screens/create/CreateScreen.tsx b/src/cli/tui/screens/create/CreateScreen.tsx
index 69d3325f..212d1a47 100644
--- a/src/cli/tui/screens/create/CreateScreen.tsx
+++ b/src/cli/tui/screens/create/CreateScreen.tsx
@@ -1,5 +1,6 @@
 import { DEFAULT_MODEL_IDS, ProjectNameSchema } from '../../../../schema';
 import { validateFolderNotExists } from '../../../commands/create/validate';
+import { VPC_ENDPOINT_WARNING } from '../../../commands/shared/vpc-utils';
 import { computeDefaultCredentialEnvVarName } from '../../../primitives/credential-utils';
 import {
   LogLink,
@@ -83,6 +84,12 @@ function buildExitMessage(projectName: string, steps: Step[], agentConfig: AddAg
     lines.push('');
   }
 
+  // VPC endpoint warning
+  if (agentConfig?.networkMode === 'VPC') {
+    lines.push(`\x1b[33mNote: ${VPC_ENDPOINT_WARNING}\x1b[0m`);
+    lines.push('');
+  }
+
   // Success message
   lines.push('\x1b[32mProject created successfully!\x1b[0m');
   lines.push('');
diff --git a/src/cli/tui/screens/generate/GenerateWizardUI.tsx b/src/cli/tui/screens/generate/GenerateWizardUI.tsx
index d5b13957..53e5ff5e 100644
--- a/src/cli/tui/screens/generate/GenerateWizardUI.tsx
+++ b/src/cli/tui/screens/generate/GenerateWizardUI.tsx
@@ -1,5 +1,6 @@
-import type { ModelProvider } from '../../../../schema';
+import type { ModelProvider, NetworkMode } from '../../../../schema';
 import { DEFAULT_MODEL_IDS, ProjectNameSchema } from '../../../../schema';
+import { validateSecurityGroupIds, validateSubnetIds } from '../../../commands/shared/vpc-utils';
 import { computeDefaultCredentialEnvVarName } from '../../../primitives/credential-utils';
 import { ApiKeySecretInput, Panel, SelectList, StepIndicator, TextInput } from '../../components';
 import type { SelectableItem } from '../../components';
@@ -9,6 +10,7 @@ import {
   BUILD_TYPE_OPTIONS,
   LANGUAGE_OPTIONS,
   MEMORY_OPTIONS,
+  NETWORK_MODE_OPTIONS,
   SDK_OPTIONS,
   STEP_LABELS,
   getModelProviderOptionsForSdk,
@@ -70,6 +72,8 @@ export function GenerateWizardUI({
         }));
       case 'memory':
         return MEMORY_OPTIONS.map(o => ({ id: o.id, title: o.title, description: o.description }));
+      case 'networkMode':
+        return NETWORK_MODE_OPTIONS.map(o => ({ id: o.id, title: o.title, description: o.description }));
       default:
         return [];
     }
@@ -79,6 +83,8 @@ export function GenerateWizardUI({
   const isSelectStep = items.length > 0;
   const isTextStep = wizard.step === 'projectName';
   const isApiKeyStep = wizard.step === 'apiKey';
+  const isSubnetsStep = wizard.step === 'subnets';
+  const isSecurityGroupsStep = wizard.step === 'securityGroups';
   const isConfirmStep = wizard.step === 'confirm';
 
   const handleSelect = (item: SelectableItem) => {
@@ -98,6 +104,9 @@ export function GenerateWizardUI({
       case 'memory':
         wizard.setMemory(item.id as MemoryOption);
         break;
+      case 'networkMode':
+        wizard.setNetworkMode(item.id as NetworkMode);
+        break;
     }
   };
 
@@ -154,6 +163,40 @@ export function GenerateWizardUI({
         />
       )}
 
+      {isSubnetsStep && (
+        <TextInput
+          prompt="Subnet IDs (comma-separated)"
+          initialValue={(wizard.config.subnets ?? []).join(', ')}
+          customValidation={validateSubnetIds}
+          onSubmit={value => {
+            wizard.setSubnets(
+              value
+                .split(',')
+                .map(s => s.trim())
+                .filter(Boolean)
+            );
+          }}
+          onCancel={onBack}
+        />
+      )}
+
+      {isSecurityGroupsStep && (
+        <TextInput
+          prompt="Security group IDs (comma-separated)"
+          initialValue={(wizard.config.securityGroups ?? []).join(', ')}
+          customValidation={validateSecurityGroupIds}
+          onSubmit={value => {
+            wizard.setSecurityGroups(
+              value
+                .split(',')
+                .map(s => s.trim())
+                .filter(Boolean)
+            );
+          }}
+          onCancel={onBack}
+        />
+      )}
+
       {isConfirmStep && <ConfirmView config={wizard.config} credentialProjectName={credentialProjectName} />}
     </Panel>
   );
@@ -165,7 +208,7 @@ export function GenerateWizardUI({
 // eslint-disable-next-line react-refresh/only-export-components
 export function getWizardHelpText(step: GenerateStep): string {
   if (step === 'confirm') return 'Enter/Y confirm · Esc back';
-  if (step === 'projectName') return 'Enter submit · Esc cancel';
+  if (step === 'projectName' || step === 'subnets' || step === 'securityGroups') return 'Enter submit · Esc cancel';
   if (step === 'apiKey') return 'Enter submit · Tab show/hide · Esc back';
   return '↑↓ navigate · Enter select · Esc back';
 }
@@ -236,6 +279,22 @@ function ConfirmView({ config, credentialProjectName }: { config: GenerateConfig
           <Text dimColor>Memory: </Text>
           <Text>{memoryLabel}</Text>
         </Text>
+        <Text>
+          <Text dimColor>Network: </Text>
+          <Text>{config.networkMode ?? 'PUBLIC'}</Text>
+        </Text>
+        {config.networkMode === 'VPC' && config.subnets && (
+          <Text>
+            <Text dimColor>Subnets: </Text>
+            <Text>{config.subnets.join(', ')}</Text>
+          </Text>
+        )}
+        {config.networkMode === 'VPC' && config.securityGroups && (
+          <Text>
+            <Text dimColor>Security Groups: </Text>
+            <Text>{config.securityGroups.join(', ')}</Text>
+          </Text>
+        )}
       </Box>
     </Box>
   );
diff --git a/src/cli/tui/screens/generate/types.ts b/src/cli/tui/screens/generate/types.ts
index d83503dc..7336e93e 100644
--- a/src/cli/tui/screens/generate/types.ts
+++ b/src/cli/tui/screens/generate/types.ts
@@ -1,4 +1,4 @@
-import type { BuildType, ModelProvider, SDKFramework, TargetLanguage } from '../../../../schema';
+import type { BuildType, ModelProvider, NetworkMode, SDKFramework, TargetLanguage } from '../../../../schema';
 import { DEFAULT_MODEL_IDS, getSupportedModelProviders } from '../../../../schema';
 
 export type GenerateStep =
@@ -9,6 +9,9 @@ export type GenerateStep =
   | 'modelProvider'
   | 'apiKey'
   | 'memory'
+  | 'networkMode'
+  | 'subnets'
+  | 'securityGroups'
   | 'confirm';
 
 export type MemoryOption = 'none' | 'shortTerm' | 'longAndShortTerm';
@@ -25,9 +28,12 @@ export interface GenerateConfig {
   apiKey?: string;
   memory: MemoryOption;
   language: TargetLanguage;
+  networkMode?: NetworkMode;
+  subnets?: string[];
+  securityGroups?: string[];
 }
 
-/** Base steps - apiKey and memory are conditionally added based on selections */
+/** Base steps - apiKey, memory, subnets, securityGroups are conditionally added based on selections */
 export const BASE_GENERATE_STEPS: GenerateStep[] = [
   'projectName',
   'language',
@@ -35,6 +41,7 @@ export const BASE_GENERATE_STEPS: GenerateStep[] = [
   'sdk',
   'modelProvider',
   'apiKey',
+  'networkMode',
   'confirm',
 ];
 
@@ -46,6 +53,9 @@ export const STEP_LABELS: Record<GenerateStep, string> = {
   modelProvider: 'Model',
   apiKey: 'API Key',
   memory: 'Memory',
+  networkMode: 'Network',
+  subnets: 'Subnets',
+  securityGroups: 'Security Groups',
   confirm: 'Confirm',
 };
 
@@ -85,6 +95,11 @@ export function getModelProviderOptionsForSdk(sdk: SDKFramework) {
   return MODEL_PROVIDER_OPTIONS.filter(option => supportedProviders.includes(option.id));
 }
 
+export const NETWORK_MODE_OPTIONS = [
+  { id: 'PUBLIC', title: 'Public', description: undefined },
+  { id: 'VPC', title: 'VPC', description: 'Attach to your VPC' },
+] as const;
+
 export const MEMORY_OPTIONS = [
   { id: 'none', title: 'None', description: 'No memory' },
   { id: 'shortTerm', title: 'Short-term memory', description: 'Context within a session' },
diff --git a/src/cli/tui/screens/generate/useGenerateWizard.ts b/src/cli/tui/screens/generate/useGenerateWizard.ts
index 9f5e653c..baaabfcf 100644
--- a/src/cli/tui/screens/generate/useGenerateWizard.ts
+++ b/src/cli/tui/screens/generate/useGenerateWizard.ts
@@ -1,3 +1,4 @@
+import type { NetworkMode } from '../../../../schema';
 import { ProjectNameSchema } from '../../../../schema';
 import type { BuildType, GenerateConfig, GenerateStep, MemoryOption } from './types';
 import { BASE_GENERATE_STEPS, getModelProviderOptionsForSdk } from './types';
@@ -33,8 +34,8 @@ export function useGenerateWizard(options?: UseGenerateWizardOptions) {
   // Track if user has selected a framework (moved past sdk step)
   const [sdkSelected, setSdkSelected] = useState(false);
 
-  // Steps depend on SDK, model provider, and whether we have an initial name
-  // Filter out: projectName if initialName, apiKey for Bedrock
+  // Steps depend on SDK, model provider, network mode, and whether we have an initial name
+  // Filter out: projectName if initialName, apiKey for Bedrock, subnets/securityGroups for non-VPC
   // Add memory step only for Strands SDK after user has selected it
   const steps = useMemo(() => {
     let filtered = BASE_GENERATE_STEPS;
@@ -45,11 +46,15 @@ export function useGenerateWizard(options?: UseGenerateWizardOptions) {
       filtered = filtered.filter(s => s !== 'apiKey');
     }
     if (sdkSelected && config.sdk === 'Strands') {
+      const networkModeIndex = filtered.indexOf('networkMode');
+      filtered = [...filtered.slice(0, networkModeIndex), 'memory', ...filtered.slice(networkModeIndex)];
+    }
+    if (config.networkMode === 'VPC') {
       const confirmIndex = filtered.indexOf('confirm');
-      filtered = [...filtered.slice(0, confirmIndex), 'memory', ...filtered.slice(confirmIndex)];
+      filtered = [...filtered.slice(0, confirmIndex), 'subnets', 'securityGroups', ...filtered.slice(confirmIndex)];
     }
     return filtered;
-  }, [config.modelProvider, config.sdk, hasInitialName, sdkSelected]);
+  }, [config.modelProvider, config.sdk, config.networkMode, hasInitialName, sdkSelected]);
 
   const currentIndex = steps.indexOf(step);
 
@@ -98,7 +103,7 @@ export function useGenerateWizard(options?: UseGenerateWizardOptions) {
       } else if (config.sdk === 'Strands') {
         setStep('memory');
       } else {
-        setStep('confirm');
+        setStep('networkMode');
       }
     },
     [config.sdk]
@@ -110,7 +115,7 @@ export function useGenerateWizard(options?: UseGenerateWizardOptions) {
       if (config.sdk === 'Strands') {
         setStep('memory');
       } else {
-        setStep('confirm');
+        setStep('networkMode');
       }
     },
     [config.sdk]
@@ -120,12 +125,31 @@ export function useGenerateWizard(options?: UseGenerateWizardOptions) {
     if (config.sdk === 'Strands') {
       setStep('memory');
     } else {
-      setStep('confirm');
+      setStep('networkMode');
     }
   }, [config.sdk]);
 
   const setMemory = useCallback((memory: MemoryOption) => {
     setConfig(c => ({ ...c, memory }));
+    setStep('networkMode');
+  }, []);
+
+  const setNetworkMode = useCallback((networkMode: NetworkMode) => {
+    setConfig(c => ({ ...c, networkMode }));
+    if (networkMode === 'VPC') {
+      setStep('subnets');
+    } else {
+      setStep('confirm');
+    }
+  }, []);
+
+  const setSubnets = useCallback((subnets: string[]) => {
+    setConfig(c => ({ ...c, subnets }));
+    setStep('securityGroups');
+  }, []);
+
+  const setSecurityGroups = useCallback((securityGroups: string[]) => {
+    setConfig(c => ({ ...c, securityGroups }));
     setStep('confirm');
   }, []);
 
@@ -168,6 +192,9 @@ export function useGenerateWizard(options?: UseGenerateWizardOptions) {
     setApiKey,
     skipApiKey,
     setMemory,
+    setNetworkMode,
+    setSubnets,
+    setSecurityGroups,
     goBack,
     reset,
     initWithName,
diff --git a/src/schema/__tests__/constants.test.ts b/src/schema/__tests__/constants.test.ts
index f2d1793e..63936fc2 100644
--- a/src/schema/__tests__/constants.test.ts
+++ b/src/schema/__tests__/constants.test.ts
@@ -97,12 +97,12 @@ describe('NetworkModeSchema', () => {
     expect(NetworkModeSchema.safeParse('PUBLIC').success).toBe(true);
   });
 
-  it('accepts PRIVATE', () => {
-    expect(NetworkModeSchema.safeParse('PRIVATE').success).toBe(true);
+  it('accepts VPC', () => {
+    expect(NetworkModeSchema.safeParse('VPC').success).toBe(true);
   });
 
   it('rejects other modes', () => {
-    expect(NetworkModeSchema.safeParse('VPC').success).toBe(false);
+    expect(NetworkModeSchema.safeParse('PRIVATE').success).toBe(false);
   });
 });
 
diff --git a/src/schema/constants.ts b/src/schema/constants.ts
index 61d19799..7bbe4a95 100644
--- a/src/schema/constants.ts
+++ b/src/schema/constants.ts
@@ -150,5 +150,5 @@ export type NodeRuntime = z.infer<typeof NodeRuntimeSchema>;
 export const RuntimeVersionSchema = z.union([PythonRuntimeSchema, NodeRuntimeSchema]);
 export type RuntimeVersion = z.infer<typeof RuntimeVersionSchema>;
 
-export const NetworkModeSchema = z.enum(['PUBLIC', 'PRIVATE']);
+export const NetworkModeSchema = z.enum(['PUBLIC', 'VPC']);
 export type NetworkMode = z.infer<typeof NetworkModeSchema>;
diff --git a/src/schema/llm-compacted/agentcore.ts b/src/schema/llm-compacted/agentcore.ts
index 382fda92..37abc5a7 100644
--- a/src/schema/llm-compacted/agentcore.ts
+++ b/src/schema/llm-compacted/agentcore.ts
@@ -26,7 +26,12 @@ type BuildType = 'CodeZip' | 'Container';
 type PythonRuntime = 'PYTHON_3_10' | 'PYTHON_3_11' | 'PYTHON_3_12' | 'PYTHON_3_13';
 type NodeRuntime = 'NODE_18' | 'NODE_20' | 'NODE_22';
 type RuntimeVersion = PythonRuntime | NodeRuntime;
-type NetworkMode = 'PUBLIC' | 'PRIVATE';
+type NetworkMode = 'PUBLIC' | 'VPC';
+interface NetworkConfig {
+  subnets: string[]; // subnet-xxx IDs
+  securityGroups: string[]; // sg-xxx IDs
+}
+
 type MemoryStrategyType = 'SEMANTIC' | 'SUMMARIZATION' | 'USER_PREFERENCE';
 type ModelProvider = 'Bedrock' | 'Gemini' | 'OpenAI' | 'Anthropic';
 
@@ -43,6 +48,7 @@ interface AgentEnvSpec {
   runtimeVersion: RuntimeVersion;
   envVars?: EnvVar[];
   networkMode?: NetworkMode; // default 'PUBLIC'
+  networkConfig?: NetworkConfig; // Required when networkMode is 'VPC'
   instrumentation?: Instrumentation; // OTel settings
   modelProvider?: ModelProvider; // Model provider used by this agent
 }
diff --git a/src/schema/llm-compacted/mcp.ts b/src/schema/llm-compacted/mcp.ts
index a4b8f984..58fbd910 100644
--- a/src/schema/llm-compacted/mcp.ts
+++ b/src/schema/llm-compacted/mcp.ts
@@ -178,4 +178,4 @@ interface IamPolicyDocument {
 type GatewayTargetType = 'lambda' | 'mcpServer' | 'openApiSchema' | 'smithyModel' | 'apiGateway' | 'lambdaFunctionArn';
 type PythonRuntime = 'PYTHON_3_10' | 'PYTHON_3_11' | 'PYTHON_3_12' | 'PYTHON_3_13';
 type NodeRuntime = 'NODE_18' | 'NODE_20' | 'NODE_22';
-type NetworkMode = 'PUBLIC' | 'PRIVATE';
+type NetworkMode = 'PUBLIC' | 'VPC';
diff --git a/src/schema/schemas/__tests__/agent-env.test.ts b/src/schema/schemas/__tests__/agent-env.test.ts
index ebda0437..77495837 100644
--- a/src/schema/schemas/__tests__/agent-env.test.ts
+++ b/src/schema/schemas/__tests__/agent-env.test.ts
@@ -7,6 +7,7 @@ import {
   EnvVarSchema,
   GatewayNameSchema,
   InstrumentationSchema,
+  NetworkConfigSchema,
 } from '../agent-env.js';
 import { describe, expect, it } from 'vitest';
 
@@ -233,13 +234,41 @@ describe('AgentEnvSpecSchema', () => {
     expect(result.success).toBe(true);
   });
 
-  it('accepts agent with network mode', () => {
+  it('accepts agent with PUBLIC network mode', () => {
     expect(AgentEnvSpecSchema.safeParse({ ...validPythonAgent, networkMode: 'PUBLIC' }).success).toBe(true);
-    expect(AgentEnvSpecSchema.safeParse({ ...validPythonAgent, networkMode: 'PRIVATE' }).success).toBe(true);
+  });
+
+  it('accepts agent with VPC network mode and networkConfig', () => {
+    const result = AgentEnvSpecSchema.safeParse({
+      ...validPythonAgent,
+      networkMode: 'VPC',
+      networkConfig: {
+        subnets: ['subnet-12345678'],
+        securityGroups: ['sg-12345678'],
+      },
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('rejects VPC network mode without networkConfig', () => {
+    const result = AgentEnvSpecSchema.safeParse({ ...validPythonAgent, networkMode: 'VPC' });
+    expect(result.success).toBe(false);
+  });
+
+  it('rejects networkConfig without VPC network mode', () => {
+    const result = AgentEnvSpecSchema.safeParse({
+      ...validPythonAgent,
+      networkMode: 'PUBLIC',
+      networkConfig: {
+        subnets: ['subnet-12345678'],
+        securityGroups: ['sg-12345678'],
+      },
+    });
+    expect(result.success).toBe(false);
   });
 
   it('rejects invalid network mode', () => {
-    expect(AgentEnvSpecSchema.safeParse({ ...validPythonAgent, networkMode: 'VPC' }).success).toBe(false);
+    expect(AgentEnvSpecSchema.safeParse({ ...validPythonAgent, networkMode: 'PRIVATE' }).success).toBe(false);
   });
 
   it('accepts agent with instrumentation config', () => {
@@ -259,3 +288,45 @@ describe('AgentEnvSpecSchema', () => {
     expect(AgentEnvSpecSchema.safeParse({ ...validPythonAgent, name: undefined }).success).toBe(false);
   });
 });
+
+describe('NetworkConfigSchema', () => {
+  it('accepts valid subnets and security groups', () => {
+    const result = NetworkConfigSchema.safeParse({
+      subnets: ['subnet-12345678', 'subnet-abcdef1234567890a'],
+      securityGroups: ['sg-12345678'],
+    });
+    expect(result.success).toBe(true);
+  });
+
+  it('rejects invalid subnet format', () => {
+    const result = NetworkConfigSchema.safeParse({
+      subnets: ['invalid-subnet'],
+      securityGroups: ['sg-12345678'],
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it('rejects invalid security group format', () => {
+    const result = NetworkConfigSchema.safeParse({
+      subnets: ['subnet-12345678'],
+      securityGroups: ['invalid-sg'],
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it('rejects empty subnets array', () => {
+    const result = NetworkConfigSchema.safeParse({
+      subnets: [],
+      securityGroups: ['sg-12345678'],
+    });
+    expect(result.success).toBe(false);
+  });
+
+  it('rejects empty security groups array', () => {
+    const result = NetworkConfigSchema.safeParse({
+      subnets: ['subnet-12345678'],
+      securityGroups: [],
+    });
+    expect(result.success).toBe(false);
+  });
+});
diff --git a/src/schema/schemas/__tests__/mcp.test.ts b/src/schema/schemas/__tests__/mcp.test.ts
index ef50c6e5..517683a2 100644
--- a/src/schema/schemas/__tests__/mcp.test.ts
+++ b/src/schema/schemas/__tests__/mcp.test.ts
@@ -245,8 +245,8 @@ describe('RuntimeConfigSchema', () => {
     }
   });
 
-  it('accepts explicit PRIVATE networkMode', () => {
-    const result = RuntimeConfigSchema.safeParse({ ...validRuntime, networkMode: 'PRIVATE' });
+  it('accepts explicit VPC networkMode', () => {
+    const result = RuntimeConfigSchema.safeParse({ ...validRuntime, networkMode: 'VPC' });
     expect(result.success).toBe(true);
   });
 
diff --git a/src/schema/schemas/agent-env.ts b/src/schema/schemas/agent-env.ts
index cc1d7052..b6e7fd42 100644
--- a/src/schema/schemas/agent-env.ts
+++ b/src/schema/schemas/agent-env.ts
@@ -103,25 +103,60 @@ export const InstrumentationSchema = z.object({
 });
 export type Instrumentation = z.infer<typeof InstrumentationSchema>;
 
+/**
+ * Network configuration for VPC mode.
+ * Required when networkMode is 'VPC'.
+ */
+export const NetworkConfigSchema = z.object({
+  subnets: z
+    .array(z.string().regex(/^subnet-[0-9a-zA-Z]{8,17}$/))
+    .min(1)
+    .max(16),
+  securityGroups: z
+    .array(z.string().regex(/^sg-[0-9a-zA-Z]{8,17}$/))
+    .min(1)
+    .max(16),
+});
+export type NetworkConfig = z.infer<typeof NetworkConfigSchema>;
+
 /**
  * AgentEnvSpec - represents an AgentCore Runtime.
  * This is a top-level resource in the schema.
  */
-export const AgentEnvSpecSchema = z.object({
-  type: AgentTypeSchema,
-  name: AgentNameSchema,
-  build: BuildTypeSchema,
-  entrypoint: EntrypointSchema,
-  codeLocation: DirectoryPathSchema,
-  runtimeVersion: RuntimeVersionSchemaFromConstants,
-  /** Environment variables to set on the runtime */
-  envVars: z.array(EnvVarSchema).optional(),
-  /** Network mode for the runtime. Defaults to PUBLIC. */
-  networkMode: NetworkModeSchema.optional(),
-  /** Instrumentation settings for observability. Defaults to OTel enabled. */
-  instrumentation: InstrumentationSchema.optional(),
-  /** Model provider used by this agent. Optional for backwards compatibility. */
-  modelProvider: ModelProviderSchema.optional(),
-});
+export const AgentEnvSpecSchema = z
+  .object({
+    type: AgentTypeSchema,
+    name: AgentNameSchema,
+    build: BuildTypeSchema,
+    entrypoint: EntrypointSchema,
+    codeLocation: DirectoryPathSchema,
+    runtimeVersion: RuntimeVersionSchemaFromConstants,
+    /** Environment variables to set on the runtime */
+    envVars: z.array(EnvVarSchema).optional(),
+    /** Network mode for the runtime. Defaults to PUBLIC. */
+    networkMode: NetworkModeSchema.optional(),
+    /** Network configuration for VPC mode. Required when networkMode is 'VPC'. */
+    networkConfig: NetworkConfigSchema.optional(),
+    /** Instrumentation settings for observability. Defaults to OTel enabled. */
+    instrumentation: InstrumentationSchema.optional(),
+    /** Model provider used by this agent. Optional for backwards compatibility. */
+    modelProvider: ModelProviderSchema.optional(),
+  })
+  .superRefine((data, ctx) => {
+    if (data.networkMode === 'VPC' && !data.networkConfig) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: 'networkConfig is required when networkMode is VPC',
+        path: ['networkConfig'],
+      });
+    }
+    if (data.networkMode !== 'VPC' && data.networkConfig) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: 'networkConfig is only allowed when networkMode is VPC',
+        path: ['networkConfig'],
+      });
+    }
+  });
 
 export type AgentEnvSpec = z.infer<typeof AgentEnvSpecSchema>;