diff --git a/src/VirtualClient/VirtualClient.Contracts/ContainerExecutionContext.cs b/src/VirtualClient/VirtualClient.Contracts/ContainerExecutionContext.cs
new file mode 100644
index 0000000000..e20579690d
--- /dev/null
+++ b/src/VirtualClient/VirtualClient.Contracts/ContainerExecutionContext.cs
@@ -0,0 +1,129 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+namespace VirtualClient.Contracts
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Runtime.InteropServices;
+
+    /// <summary>
+    /// Tracks whether execution is happening inside a container context
+    /// and provides the effective platform for component execution.
+    /// </summary>
+    public class ContainerExecutionContext
+    {
+        private static ContainerExecutionContext current;
+
+        /// <summary>
+        /// Gets or sets the current container execution context.
+        /// </summary>
+        public static ContainerExecutionContext Current
+        {
+            get => current ??= new ContainerExecutionContext();
+            set => current = value;
+        }
+
+        /// <summary>
+        /// True if running with container mode enabled (--image was passed).
+        /// </summary>
+        public bool IsContainerMode { get; set; }
+
+        /// <summary>
+        /// The container image being used.
+        /// </summary>
+        public string Image { get; set; }
+
+        /// <summary>
+        /// The platform inside the container (typically Linux).
+        /// </summary>
+        public PlatformID ContainerPlatform { get; set; } = PlatformID.Unix;
+
+        /// <summary>
+        /// The CPU architecture inside the container.
+        /// </summary>
+        public Architecture ContainerArchitecture { get; set; } = Architecture.X64;
+
+        /// <summary>
+        /// Gets the effective platform - container platform if in container mode,
+        /// otherwise the host platform.
+        /// </summary>
+        public PlatformID EffectivePlatform => this.IsContainerMode
+            ? this.ContainerPlatform
+            : Environment.OSVersion.Platform;
+
+        /// <summary>
+        /// Gets the effective architecture.
+        /// </summary>
+        public Architecture EffectiveArchitecture => this.IsContainerMode
+            ? this.ContainerArchitecture
+            : RuntimeInformation.ProcessArchitecture;
+
+        /// <summary>
+        /// Container configuration from profile.
+        /// </summary>
+        public ContainerConfiguration Configuration { get; set; }
+    }
+
+    /// <summary>
+    /// Container configuration from profile's Container section.
+    /// </summary>
+    public class ContainerConfiguration
+    {
+        /// <summary>
+        /// Default image (can be overridden by --image CLI).
+        /// </summary>
+        public string Image { get; set; }
+
+        /// <summary>
+        /// Standard mount configuration.
+        /// </summary>
+        public ContainerMountConfig Mounts { get; set; } = new ContainerMountConfig();
+
+        /// <summary>
+        /// Working directory inside container.
+        /// </summary>
+        public string WorkingDirectory { get; set; } = "/vc";
+
+        /// <summary>
+        /// Environment variables to pass to container.
+        /// </summary>
+        public IDictionary<string, string> EnvironmentVariables { get; set; }
+
+        /// <summary>
+        /// Additional mount paths beyond the defaults.
+        /// </summary>
+        public IList<string> AdditionalMounts { get; set; }
+
+        /// <summary>
+        /// Pull policy: Always, IfNotPresent, Never.
+        /// </summary>
+        public string PullPolicy { get; set; } = "IfNotPresent";
+    }
+
+    /// <summary>
+    /// Standard VC directory mounts configuration.
+    /// </summary>
+    public class ContainerMountConfig
+    {
+        /// <summary>
+        /// Mount the packages directory (/vc/packages).
+        /// </summary>
+        public bool Packages { get; set; } = true;
+
+        /// <summary>
+        /// Mount the logs directory (/vc/logs).
+        /// </summary>
+        public bool Logs { get; set; } = true;
+
+        /// <summary>
+        /// Mount the state directory (/vc/state).
+        /// </summary>
+        public bool State { get; set; } = true;
+
+        /// <summary>
+        /// Mount the temp directory (/vc/temp).
+        /// </summary>
+        public bool Temp { get; set; } = true;
+    }
+}
\ No newline at end of file
diff --git a/src/VirtualClient/VirtualClient.Contracts/VirtualClientComponent.cs b/src/VirtualClient/VirtualClient.Contracts/VirtualClientComponent.cs
index 1e6c25f2d7..3b45d7594a 100644
--- a/src/VirtualClient/VirtualClient.Contracts/VirtualClientComponent.cs
+++ b/src/VirtualClient/VirtualClient.Contracts/VirtualClientComponent.cs
@@ -109,7 +109,7 @@ protected VirtualClientComponent(IServiceCollection dependencies, IDictionary<st
             this.Metadata = new Dictionary<string, IConvertible>(StringComparer.OrdinalIgnoreCase);
             this.MetadataContract = new MetadataContract();
             this.PlatformSpecifics = this.systemInfo.PlatformSpecifics;
-            this.Platform = this.systemInfo.Platform;
+            // this.Platform = this.systemInfo.Platform;
             this.SupportedRoles = new List<string>();
             this.CleanupTasks = new List<Action>();
             this.Extensions = new Dictionary<string, JToken>();
@@ -400,7 +400,19 @@ protected set
         /// <summary>
         /// The OS/system platform (e.g. Windows, Unix).
         /// </summary>
-        public PlatformID Platform { get; }
+        public PlatformID Platform
+        {
+            get
+            {
+                // If container mode is active, report container platform
+                if (ContainerExecutionContext.Current.IsContainerMode)
+                {
+                    return ContainerExecutionContext.Current.ContainerPlatform;
+                }
+                
+                return this.systemInfo.Platform;
+            }
+        }
 
         /// <summary>
         /// Provides OS/system platform specific information.
@@ -637,6 +649,19 @@ protected string PlatformArchitectureName
         {
             get
             {
+                // If container mode is active, report container platform/architecture
+                if (ContainerExecutionContext.Current.IsContainerMode)
+                {
+                    string os = ContainerExecutionContext.Current.ContainerPlatform == PlatformID.Unix ? "linux" : "win";
+                    string arch = ContainerExecutionContext.Current.ContainerArchitecture switch
+                    {
+                        Architecture.X64 => "x64",
+                        Architecture.Arm64 => "arm64",
+                        _ => "x64"
+                    };
+                    return $"{os}-{arch}";
+                }
+
                 return this.PlatformSpecifics.PlatformArchitectureName;
             }
         }
diff --git a/src/VirtualClient/VirtualClient.Core/ContainerAwareProcessManager.cs b/src/VirtualClient/VirtualClient.Core/ContainerAwareProcessManager.cs
new file mode 100644
index 0000000000..ae3f11bc2c
--- /dev/null
+++ b/src/VirtualClient/VirtualClient.Core/ContainerAwareProcessManager.cs
@@ -0,0 +1,258 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+namespace VirtualClient
+{
+    using System;
+    using System.Collections.Specialized;
+    using System.Diagnostics;
+    using System.IO;
+    using System.Threading;
+    using System.Threading.Tasks;
+    using VirtualClient.Common;
+    using VirtualClient.Contracts;
+
+    /// <summary>
+    /// Process manager that wraps commands in Docker when container mode is active.
+    /// </summary>
+    public class ContainerAwareProcessManager : ProcessManager
+    {
+        private readonly DockerRuntime dockerRuntime;
+        private readonly PlatformSpecifics platformSpecifics;
+        private readonly ProcessManager innerProcessManager;
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="dockerRuntime"></param>
+        /// <param name="platformSpecifics"></param>
+        /// <param name="innerProcessManager"></param>
+        /// <exception cref="ArgumentNullException"></exception>
+        public ContainerAwareProcessManager(
+            DockerRuntime dockerRuntime,
+            PlatformSpecifics platformSpecifics,
+            ProcessManager innerProcessManager)
+        {
+            this.dockerRuntime = dockerRuntime ?? throw new ArgumentNullException(nameof(dockerRuntime));
+            this.platformSpecifics = platformSpecifics ?? throw new ArgumentNullException(nameof(platformSpecifics));
+            this.innerProcessManager = innerProcessManager ?? throw new ArgumentNullException(nameof(innerProcessManager));
+        }
+
+        /// <inheritdoc/>
+        public override PlatformID Platform => this.innerProcessManager.Platform;
+
+        /// <summary>
+        /// Creates a process. If in container mode, the process runs inside Docker.
+        /// </summary>
+        public override IProcessProxy CreateProcess(string command, string arguments = null, string workingDirectory = null)
+        {
+            if (ContainerExecutionContext.Current.IsContainerMode)
+            {
+                // Wrap in Docker execution
+                return new ContainerProcessProxy(
+                    this.dockerRuntime,
+                    ContainerExecutionContext.Current.Image,
+                    command,
+                    arguments,
+                    workingDirectory,
+                    ContainerExecutionContext.Current.Configuration,
+                    this.platformSpecifics);
+            }
+
+            // Normal host execution - delegate to inner manager
+            return this.innerProcessManager.CreateProcess(command, arguments, workingDirectory);
+        }
+    }
+
+    /// <summary>
+    /// Process proxy that executes inside a container.
+    /// </summary>
+    public class ContainerProcessProxy : IProcessProxy
+    {
+        private readonly DockerRuntime runtime;
+        private readonly string image;
+        private readonly string command;
+        private readonly string arguments;
+        private readonly string workingDirectory;
+        private readonly ContainerConfiguration config;
+        private readonly PlatformSpecifics platformSpecifics;
+        
+        private DockerRunResult result;
+        private bool hasStarted;
+        private DateTime startTime;
+        private DateTime exitTime;
+        private bool disposed;
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="runtime"></param>
+        /// <param name="image"></param>
+        /// <param name="command"></param>
+        /// <param name="arguments"></param>
+        /// <param name="workingDirectory"></param>
+        /// <param name="config"></param>
+        /// <param name="platformSpecifics"></param>
+        /// <exception cref="ArgumentNullException"></exception>
+        public ContainerProcessProxy(
+            DockerRuntime runtime,
+            string image,
+            string command,
+            string arguments,
+            string workingDirectory,
+            ContainerConfiguration config,
+            PlatformSpecifics platformSpecifics)
+        {
+            this.runtime = runtime ?? throw new ArgumentNullException(nameof(runtime));
+            this.image = image ?? throw new ArgumentNullException(nameof(image));
+            this.command = command;
+            this.arguments = arguments;
+            this.workingDirectory = workingDirectory;
+            this.config = config;
+            this.platformSpecifics = platformSpecifics;
+            
+            this.StandardOutput = new ConcurrentBuffer();
+            this.StandardError = new ConcurrentBuffer();
+        }
+
+        /// <inheritdoc/>
+        public int Id => -1; // Container processes don't have a host PID
+
+        /// <inheritdoc/>
+        public string Name => $"docker:{this.image}";
+
+        /// <inheritdoc/>
+        public StringDictionary EnvironmentVariables => null;
+
+        /// <inheritdoc/>
+        public int ExitCode => this.result?.ExitCode ?? -1;
+
+        /// <inheritdoc/>
+        public DateTime ExitTime
+        {
+            get => this.exitTime;
+            set => this.exitTime = value;
+        }
+
+        /// <inheritdoc/>
+        public IntPtr? Handle => null;
+
+        /// <inheritdoc/>
+        public bool HasExited => this.result != null;
+
+        /// <inheritdoc/>
+        public bool RedirectStandardError { get; set; } = true;
+
+        /// <inheritdoc/>
+        public bool RedirectStandardInput { get; set; } = false;
+
+        /// <inheritdoc/>
+        public bool RedirectStandardOutput { get; set; } = true;
+
+        /// <inheritdoc/>
+        public ConcurrentBuffer StandardOutput { get; }
+
+        /// <inheritdoc/>
+        public ConcurrentBuffer StandardError { get; }
+
+        /// <inheritdoc/>
+        public StreamWriter StandardInput => null;
+
+        /// <inheritdoc/>
+        public ProcessStartInfo StartInfo => new ProcessStartInfo
+        {
+            FileName = "docker",
+            Arguments = $"run {this.image} {this.command} {this.arguments}".Trim()
+        };
+
+        /// <inheritdoc/>
+        public DateTime StartTime
+        {
+            get => this.startTime;
+            set => this.startTime = value;
+        }
+
+        /// <inheritdoc/>
+        public void Close()
+        {
+            // Container is already removed with --rm flag
+        }
+
+        /// <inheritdoc />
+        public void Dispose()
+        {
+            this.Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        /// <inheritdoc/>
+        public void Kill()
+        {
+            // TODO: Implement docker stop/kill if needed
+        }
+
+        /// <inheritdoc/>
+        public void Kill(bool entireProcessTree)
+        {
+            this.Kill();
+        }
+
+        /// <inheritdoc/>
+        public bool Start()
+        {
+            this.hasStarted = true;
+            this.startTime = DateTime.UtcNow;
+            return true;
+        }
+
+        /// <inheritdoc/>
+        public async Task WaitForExitAsync(CancellationToken cancellationToken, TimeSpan? timeout = null)
+        {
+            if (!this.hasStarted)
+            {
+                this.Start();
+            }
+
+            var fullCommand = string.IsNullOrWhiteSpace(this.arguments)
+                ? this.command
+                : $"{this.command} {this.arguments}";
+
+            this.result = await this.runtime.RunAsync(
+                this.image,
+                fullCommand,
+                this.config,
+                this.platformSpecifics,
+                cancellationToken);
+
+            this.exitTime = DateTime.UtcNow;
+            this.StandardOutput.Append(this.result.StandardOutput ?? string.Empty);
+            this.StandardError.Append(this.result.StandardError ?? string.Empty);
+        }
+
+        /// <inheritdoc/>
+        public IProcessProxy WriteInput(string input)
+        {
+            // Container stdin not supported in this implementation
+            return this;
+        }
+
+        /// <summary>
+        /// Disposes of resources used by the proxy.
+        /// </summary>
+        /// <param name="disposing">True to dispose of unmanaged resources.</param>
+        protected virtual void Dispose(bool disposing)
+        {
+            if (!this.disposed)
+            {
+                if (disposing)
+                {
+                    // no underlying process defined yet.
+                    ////this.UnderlyingProcess.Close();
+                    ////this.UnderlyingProcess.Dispose();
+                }
+
+                this.disposed = true;
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/VirtualClient/VirtualClient.Core/DockerRuntime.cs b/src/VirtualClient/VirtualClient.Core/DockerRuntime.cs
new file mode 100644
index 0000000000..1761f36399
--- /dev/null
+++ b/src/VirtualClient/VirtualClient.Core/DockerRuntime.cs
@@ -0,0 +1,247 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+namespace VirtualClient
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Text;
+    using System.Threading;
+    using System.Threading.Tasks;
+    using Microsoft.Extensions.Logging;
+    using VirtualClient.Common;
+    using VirtualClient.Common.Extensions;
+    using VirtualClient.Contracts;
+
+    /// <summary>
+    /// Docker runtime for executing commands inside containers.
+    /// </summary>
+    public class DockerRuntime
+    {
+        private readonly ProcessManager processManager;
+        private readonly PlatformSpecifics platformSpecifics;
+        private readonly ILogger logger;
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="processManager"></param>
+        /// <param name="platformSpecifics"></param>
+        /// <param name="logger"></param>
+        public DockerRuntime(ProcessManager processManager, PlatformSpecifics platformSpecifics, ILogger logger = null)
+        {
+            processManager.ThrowIfNull(nameof(processManager));
+            platformSpecifics.ThrowIfNull(nameof(platformSpecifics));
+            this.processManager = processManager;
+            this.platformSpecifics = platformSpecifics;
+            this.logger = logger;
+        }
+
+        /// <summary>
+        /// Checks if Docker is available and configured for Linux containers.
+        /// </summary>
+        public async Task<bool> IsAvailableAsync(CancellationToken cancellationToken)
+        {
+            try
+            {
+                using IProcessProxy process = this.processManager.CreateProcess("docker", "info --format {{.OSType}}");
+                await process.StartAndWaitAsync(cancellationToken);
+
+                string osType = process.StandardOutput.ToString().Trim().ToLowerInvariant();
+                return process.ExitCode == 0 && osType.Contains("linux");
+            }
+            catch
+            {
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Checks if an image exists locally.
+        /// </summary>
+        public async Task<bool> ImageExistsAsync(string image, CancellationToken cancellationToken)
+        {
+            using IProcessProxy process = this.processManager.CreateProcess("docker", $"image inspect {image}");
+            await process.StartAndWaitAsync(cancellationToken);
+            return process.ExitCode == 0;
+        }
+
+        /// <summary>
+        /// Pulls an image.
+        /// </summary>
+        public async Task PullImageAsync(string image, CancellationToken cancellationToken)
+        {
+            this.logger?.LogInformation("Pulling Docker image: {Image}", image);
+
+            using IProcessProxy process = this.processManager.CreateProcess("docker", $"pull {image}");
+            await process.StartAndWaitAsync(cancellationToken);
+
+            if (process.ExitCode != 0)
+            {
+                throw new DependencyException(
+                    $"Failed to pull Docker image '{image}': {process.StandardError}",
+                    ErrorReason.DependencyInstallationFailed);
+            }
+        }
+
+        /// <summary>
+        /// Executes a command inside a container.
+        /// </summary>
+        public async Task<DockerRunResult> RunAsync(
+            string image,
+            string command,
+            ContainerConfiguration config,
+            PlatformSpecifics hostPlatformSpecifics,
+            CancellationToken cancellationToken)
+        {
+            string containerName = $"vc-{Guid.NewGuid():N}"[..32];
+            string args = this.BuildDockerRunArgs(image, command, config, containerName, hostPlatformSpecifics);
+
+            this.logger?.LogInformation("Running container: {ContainerName}", containerName);
+            this.logger?.LogDebug("Docker command: docker {Args}", args);
+
+            var result = new DockerRunResult
+            {
+                ContainerName = containerName,
+                StartTime = DateTime.UtcNow
+            };
+
+            using IProcessProxy process = this.processManager.CreateProcess("docker", args);
+
+            await process.StartAndWaitAsync(cancellationToken);
+
+            result.EndTime = DateTime.UtcNow;
+            result.ExitCode = process.ExitCode;
+            result.StandardOutput = process.StandardOutput.ToString();
+            result.StandardError = process.StandardError.ToString();
+
+            this.logger?.LogDebug("Container {ContainerName} exited with code {ExitCode}", containerName, result.ExitCode);
+
+            return result;
+        }
+
+        private string BuildDockerRunArgs(
+            string image,
+            string command,
+            ContainerConfiguration config,
+            string containerName,
+            PlatformSpecifics hostPlatformSpecifics)
+        {
+            var args = new List<string>
+            {
+                "run",
+                "--rm",
+                $"--name {containerName}"
+            };
+
+            // Working directory
+            string workDir = config?.WorkingDirectory ?? "/vc";
+            args.Add($"-w {workDir}");
+
+            // Standard mounts
+            ContainerMountConfig mounts = config?.Mounts ?? new ContainerMountConfig();
+
+            if (mounts.Packages)
+            {
+                string hostPath = this.ToDockerPath(hostPlatformSpecifics.PackagesDirectory);
+                args.Add($"-v \"{hostPath}:/vc/packages\"");
+            }
+
+            if (mounts.Logs)
+            {
+                string hostPath = this.ToDockerPath(hostPlatformSpecifics.LogsDirectory);
+                args.Add($"-v \"{hostPath}:/vc/logs\"");
+            }
+
+            if (mounts.State)
+            {
+                string hostPath = this.ToDockerPath(hostPlatformSpecifics.StateDirectory);
+                args.Add($"-v \"{hostPath}:/vc/state\"");
+            }
+
+            if (mounts.Temp)
+            {
+                string hostPath = this.ToDockerPath(hostPlatformSpecifics.TempDirectory);
+                args.Add($"-v \"{hostPath}:/vc/temp\"");
+            }
+
+            // Additional mounts
+            if (config?.AdditionalMounts?.Any() == true)
+            {
+                foreach (string mount in config.AdditionalMounts)
+                {
+                    args.Add($"-v \"{mount}\"");
+                }
+            }
+
+            // Environment variables
+            if (config?.EnvironmentVariables?.Any() == true)
+            {
+                foreach (KeyValuePair<string, string> env in config.EnvironmentVariables)
+                {
+                    args.Add($"-e \"{env.Key}={env.Value}\"");
+                }
+            }
+
+            // Always pass these VC context vars
+            args.Add("-e \"VC_CONTAINER_MODE=true\"");
+
+            // Image
+            args.Add(image);
+
+            // Command (if provided)
+            if (!string.IsNullOrWhiteSpace(command))
+            {
+                args.Add(command);
+            }
+
+            return string.Join(" ", args);
+        }
+
+        /// <summary>
+        /// Converts Windows path to Docker-compatible format.
+        /// C:\path\to\dir -> /c/path/to/dir
+        /// </summary>
+        private string ToDockerPath(string path)
+        {
+            if (this.platformSpecifics.Platform == PlatformID.Win32NT && path.Length >= 2 && path[1] == ':')
+            {
+                char drive = char.ToLower(path[0]);
+                return $"/{drive}{path[2..].Replace('\\', '/')}";
+            }
+
+            return path;
+        }
+    }
+
+    /// <summary>
+    /// Result of a Docker run operation.
+    /// </summary>
+    public class DockerRunResult
+    {
+        /// <summary>Container name.</summary>
+        public string ContainerName { get; set; }
+
+        /// <summary>Exit code from the container.</summary>
+        public int ExitCode { get; set; }
+
+        /// <summary>Standard output from the container.</summary>
+        public string StandardOutput { get; set; }
+
+        /// <summary>Standard error from the container.</summary>
+        public string StandardError { get; set; }
+
+        /// <summary>When the container started.</summary>
+        public DateTime StartTime { get; set; }
+
+        /// <summary>When the container exited.</summary>
+        public DateTime EndTime { get; set; }
+
+        /// <summary>Duration of execution.</summary>
+        public TimeSpan Duration => this.EndTime - this.StartTime;
+
+        /// <summary>True if exit code was 0.</summary>
+        public bool Succeeded => this.ExitCode == 0;
+    }
+}
\ No newline at end of file
diff --git a/src/VirtualClient/VirtualClient.Main/CommandLineParser.cs b/src/VirtualClient/VirtualClient.Main/CommandLineParser.cs
index b21f54fae9..94f67c5144 100644
--- a/src/VirtualClient/VirtualClient.Main/CommandLineParser.cs
+++ b/src/VirtualClient/VirtualClient.Main/CommandLineParser.cs
@@ -156,7 +156,15 @@ public static CommandLineParser Create(IEnumerable<string> args, CancellationTok
                 OptionFactory.CreateTimeoutOption(required: false),
 
                 // --verbose
-                OptionFactory.CreateVerboseFlag(required: false, false)
+                OptionFactory.CreateVerboseFlag(required: false, false),
+
+                // CONTAINER OPTIONS
+                // -------------------------------------------------------------------
+                // --image
+                OptionFactory.CreateImageOption(required: false),
+
+                // --pull-policy
+                OptionFactory.CreatePullPolicyOption(required: false)
             };
 
             rootCommand.TreatUnmatchedTokensAsErrors = true;
diff --git a/src/VirtualClient/VirtualClient.Main/ExecuteProfileCommand.cs b/src/VirtualClient/VirtualClient.Main/ExecuteProfileCommand.cs
index bf5c5f655b..7ee7ec731d 100644
--- a/src/VirtualClient/VirtualClient.Main/ExecuteProfileCommand.cs
+++ b/src/VirtualClient/VirtualClient.Main/ExecuteProfileCommand.cs
@@ -669,7 +669,7 @@ protected void SetHostMetadataTelemetryProperties(IEnumerable<string> profiles,
                 new Dictionary<string, object>
                 {
                     { "exitWait", this.ExitWait },
-                    { "layout", this.Layout.ToString() },
+                    { "layout", this.Layout?.ToString() },
                     { "logToFile", this.LogToFile },
                     { "iterations", this.Iterations?.ProfileIterations },
                     { "profiles", string.Join(",", profiles.Select(p => Path.GetFileName(p))) },
diff --git a/src/VirtualClient/VirtualClient.Main/Images/Dockerfile.ubuntu b/src/VirtualClient/VirtualClient.Main/Images/Dockerfile.ubuntu
new file mode 100644
index 0000000000..c7a9c9eb3b
--- /dev/null
+++ b/src/VirtualClient/VirtualClient.Main/Images/Dockerfile.ubuntu
@@ -0,0 +1,55 @@
+# VirtualClient Ubuntu Base Image
+# This image provides a Linux environment for running workloads from Windows hosts
+
+FROM ubuntu:22.04
+
+LABEL maintainer="VirtualClient Team"
+LABEL description="Ubuntu base image for VirtualClient containerized workload execution"
+
+# Prevent interactive prompts during package installation
+ENV DEBIAN_FRONTEND=noninteractive
+
+# Install common dependencies needed for most workloads
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    # Build essentials
+    build-essential \
+    gcc \
+    g++ \
+    make \
+    cmake \
+    # Common utilities
+    curl \
+    wget \
+    git \
+    unzip \
+    tar \
+    gzip \
+    # Python (many workloads need it)
+    python3 \
+    python3-pip \
+    # Libraries
+    libc6-dev \
+    libssl-dev \
+    libffi-dev \
+    libnuma-dev \
+    # Debugging tools
+    strace \
+    htop \
+    procps \
+    # Cleanup
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+# Create standard VC directories
+RUN mkdir -p /vc/packages /vc/logs /vc/state /vc/temp /vc/output
+
+# Set working directory
+WORKDIR /vc
+
+# Default environment variables
+ENV VC_CONTAINER_MODE=true
+ENV LC_ALL=C.UTF-8
+ENV LANG=C.UTF-8
+
+# Default command (can be overridden)
+CMD ["/bin/bash"]
\ No newline at end of file
diff --git a/src/VirtualClient/VirtualClient.Main/Images/build-image.ps1 b/src/VirtualClient/VirtualClient.Main/Images/build-image.ps1
new file mode 100644
index 0000000000..08f0999f69
--- /dev/null
+++ b/src/VirtualClient/VirtualClient.Main/Images/build-image.ps1
@@ -0,0 +1,23 @@
+# Build script for VirtualClient Ubuntu image
+param(
+    [string]$ImageName = "vc-ubuntu",
+    [string]$Tag = "22.04"
+)
+
+$ScriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path
+$DockerfilePath = Join-Path $ScriptDir "Dockerfile.ubuntu"
+
+Write-Host "Building VirtualClient Ubuntu image..." -ForegroundColor Cyan
+Write-Host "Dockerfile: $DockerfilePath" -ForegroundColor Gray
+
+docker build -t "${ImageName}:${Tag}" -f $DockerfilePath $ScriptDir
+
+if ($LASTEXITCODE -eq 0) {
+    Write-Host "`nImage built successfully!" -ForegroundColor Green
+    Write-Host "Image: ${ImageName}:${Tag}" -ForegroundColor Green
+    Write-Host "`nTo run VirtualClient with this image:" -ForegroundColor Yellow
+    Write-Host "  VirtualClient.exe --profile=PERF-CPU-OPENSSL.json --image=${ImageName}:${Tag}" -ForegroundColor White
+} else {
+    Write-Host "`nBuild failed!" -ForegroundColor Red
+    exit 1
+}
\ No newline at end of file
diff --git a/src/VirtualClient/VirtualClient.Main/OptionFactory.Container.cs b/src/VirtualClient/VirtualClient.Main/OptionFactory.Container.cs
new file mode 100644
index 0000000000..e07f2a171c
--- /dev/null
+++ b/src/VirtualClient/VirtualClient.Main/OptionFactory.Container.cs
@@ -0,0 +1,35 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+namespace VirtualClient
+{
+    using System.CommandLine;
+
+    public static partial class OptionFactory
+    {
+        /// <summary>
+        /// Container image for workload execution.
+        /// When provided, VC runs workloads inside this container.
+        /// </summary>
+        public static Option CreateImageOption(bool required = false)
+        {
+            return new Option<string>(
+                aliases: new[] { "--image", "-i" },
+                description: "Docker image for containerized execution. When provided, workloads run inside the container.")
+            {
+                IsRequired = required
+            };
+        }
+
+        /// <summary>
+        /// Image pull policy.
+        /// </summary>
+        public static Option CreatePullPolicyOption(bool required = false)
+        {
+            return new Option<string>(
+                aliases: new[] { "--pull-policy" },
+                getDefaultValue: () => "IfNotPresent",
+                description: "Image pull policy: Always, IfNotPresent, Never. Default: IfNotPresent");
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/VirtualClient/VirtualClient.Main/OptionFactory.cs b/src/VirtualClient/VirtualClient.Main/OptionFactory.cs
index a69948c09c..7aed8d7397 100644
--- a/src/VirtualClient/VirtualClient.Main/OptionFactory.cs
+++ b/src/VirtualClient/VirtualClient.Main/OptionFactory.cs
@@ -26,7 +26,7 @@ namespace VirtualClient
     /// Provides a factory for the creation of Command Options used by application command line operations.
     /// </summary>
     [SuppressMessage("StyleCop.CSharp.ReadabilityRules", "SA1118:Parameter should not span multiple lines", Justification = "Allow for longer description text.")]
-    public static class OptionFactory
+    public static partial class OptionFactory
     {
         internal const string HtmlQuote = "&quot;";
         private static readonly ICertificateManager defaultCertificateManager = new CertificateManager();