@@ -285,6 +285,15 @@ public void configureWorkerFactory(@Nonnull WorkerFactoryOptions.Builder builder
       combined.addAll(workerInterceptors);
       builder.setWorkerInterceptors(combined.toArray(new WorkerInterceptor[0]));
     }
+
+    // Add context propagators
+    if (!contextPropagators.isEmpty()) {
+      List<ContextPropagator> existing = builder.build().getContextPropagators();
+      List<ContextPropagator> combined =
+          new ArrayList<>(existing != null ? existing : new ArrayList<>());
+      combined.addAll(contextPropagators);
+      builder.setContextPropagators(combined);
+    }
   }
 
   @Override
 
@@ -10,6 +10,7 @@
 import io.temporal.api.workflowservice.v1.DescribeNamespaceResponse;
 import io.temporal.client.WorkflowClient;
 import io.temporal.client.WorkflowClientOptions;
+import io.temporal.common.context.ContextPropagator;
 import io.temporal.common.converter.DataConverter;
 import io.temporal.internal.client.WorkflowClientInternal;
 import io.temporal.internal.common.PluginUtils;
@@ -27,6 +28,7 @@
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Objects;
@@ -192,6 +194,16 @@ public synchronized Worker newWorker(String taskQueue, WorkerOptions options) {
     // Apply plugin configuration to worker options (forward order)
     options = applyWorkerPluginConfiguration(taskQueue, options, this.plugins);
 
+    Map<String, ContextPropagator> contextPropagatorsByName = new LinkedHashMap<>();
+    for (ContextPropagator propagator : workflowClient.getOptions().getContextPropagators()) {
+      contextPropagatorsByName.putIfAbsent(propagator.getName(), propagator);
+    }
+    for (ContextPropagator propagator : factoryOptions.getContextPropagators()) {
+      contextPropagatorsByName.putIfAbsent(propagator.getName(), propagator);
+    }
+    List<ContextPropagator> contextPropagators =
+        new ArrayList<>(contextPropagatorsByName.values());
+
     // Only one worker can exist for a task queue
     Worker existingWorker = workers.get(taskQueue);
     if (existingWorker == null) {
@@ -206,7 +218,7 @@ public synchronized Worker newWorker(String taskQueue, WorkerOptions options) {
               cache,
               true,
               workflowThreadExecutor,
-              workflowClient.getOptions().getContextPropagators(),
+              contextPropagators,
               plugins,
               ((WorkflowClientInternal) workflowClient.getInternal()).getWorkerGroupingKey(),
               namespaceCapabilities);
 
@@ -3,8 +3,11 @@
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.base.Preconditions;
 import io.temporal.common.Experimental;
+import io.temporal.common.context.ContextPropagator;
 import io.temporal.common.interceptors.WorkerInterceptor;
 import java.time.Duration;
+import java.util.Collections;
+import java.util.List;
 import java.util.concurrent.ExecutorService;
 import javax.annotation.Nullable;
 
@@ -38,6 +41,7 @@ public static class Builder {
     private int workflowCacheSize;
     private int maxWorkflowThreadCount;
     private WorkerInterceptor[] workerInterceptors;
+    private List<ContextPropagator> contextPropagators;
     private WorkerPlugin[] plugins;
     private boolean enableLoggingInReplay;
     private boolean usingVirtualWorkflowThreads;
@@ -55,6 +59,7 @@ private Builder(WorkerFactoryOptions options) {
       this.workflowCacheSize = options.workflowCacheSize;
       this.maxWorkflowThreadCount = options.maxWorkflowThreadCount;
       this.workerInterceptors = options.workerInterceptors;
+      this.contextPropagators = options.contextPropagators;
       this.plugins = options.plugins;
       this.enableLoggingInReplay = options.enableLoggingInReplay;
       this.usingVirtualWorkflowThreads = options.usingVirtualWorkflowThreads;
@@ -106,6 +111,15 @@ public Builder setWorkerInterceptors(WorkerInterceptor... workerInterceptors) {
       return this;
     }
 
+    /**
+     * Sets the context propagators to use with workers created by this factory. These are appended
+     * to the propagators configured on the workflow client.
+     */
+    public Builder setContextPropagators(List<ContextPropagator> contextPropagators) {
+      this.contextPropagators = contextPropagators;
+      return this;
+    }
+
     /**
      * Sets the worker plugins to use with workers created by this factory. Plugins can modify
      * worker configuration and wrap worker lifecycle.
@@ -179,6 +193,7 @@ public WorkerFactoryOptions build() {
           maxWorkflowThreadCount,
           workflowHostLocalTaskQueueScheduleToStartTimeout,
           workerInterceptors,
+          contextPropagators,
           plugins,
           enableLoggingInReplay,
           usingVirtualWorkflowThreads,
@@ -204,6 +219,7 @@ public WorkerFactoryOptions validateAndBuildWithDefaults() {
           maxWorkflowThreadCount,
           workflowHostLocalTaskQueueScheduleToStartTimeout,
           workerInterceptors == null ? new WorkerInterceptor[0] : workerInterceptors,
+          contextPropagators == null ? Collections.emptyList() : contextPropagators,
           plugins == null ? new WorkerPlugin[0] : plugins,
           enableLoggingInReplay,
           usingVirtualWorkflowThreads,
@@ -217,6 +233,7 @@ public WorkerFactoryOptions validateAndBuildWithDefaults() {
   private final int maxWorkflowThreadCount;
   private final @Nullable Duration workflowHostLocalTaskQueueScheduleToStartTimeout;
   private final WorkerInterceptor[] workerInterceptors;
+  private final List<ContextPropagator> contextPropagators;
   private final WorkerPlugin[] plugins;
   private final boolean enableLoggingInReplay;
   private final boolean usingVirtualWorkflowThreads;
@@ -228,6 +245,7 @@ private WorkerFactoryOptions(
       int maxWorkflowThreadCount,
       @Nullable Duration workflowHostLocalTaskQueueScheduleToStartTimeout,
       WorkerInterceptor[] workerInterceptors,
+      List<ContextPropagator> contextPropagators,
       WorkerPlugin[] plugins,
       boolean enableLoggingInReplay,
       boolean usingVirtualWorkflowThreads,
@@ -268,6 +286,7 @@ private WorkerFactoryOptions(
     this.workflowHostLocalTaskQueueScheduleToStartTimeout =
         workflowHostLocalTaskQueueScheduleToStartTimeout;
     this.workerInterceptors = workerInterceptors;
+    this.contextPropagators = contextPropagators;
     this.plugins = plugins;
     this.enableLoggingInReplay = enableLoggingInReplay;
     this.usingVirtualWorkflowThreads = usingVirtualWorkflowThreads;
@@ -292,6 +311,15 @@ public WorkerInterceptor[] getWorkerInterceptors() {
     return workerInterceptors;
   }
 
+  /**
+   * Returns the context propagators used with workers created by this factory.
+   *
+   * @return the list of context propagators, never null
+   */
+  public List<ContextPropagator> getContextPropagators() {
+    return contextPropagators;
+  }
+
   /**
    * Returns the worker plugins configured for this factory.
    *
 
@@ -30,6 +30,7 @@
 import io.temporal.client.WorkflowClientOptions;
 import io.temporal.client.schedules.ScheduleClientOptions;
 import io.temporal.client.schedules.ScheduleClientPlugin;
+import io.temporal.common.context.ContextPropagator;
 import io.temporal.common.converter.DataConverter;
 import io.temporal.common.interceptors.ActivityClientInterceptor;
 import io.temporal.common.interceptors.ActivityClientInterceptorBase;
@@ -88,6 +89,18 @@ public void testAddWorkerInterceptors() {
     assertSame(interceptor, interceptors[0]);
   }
 
+  @Test
+  public void testAddContextPropagatorsToWorkerFactory() {
+    ContextPropagator propagator = mock(ContextPropagator.class);
+
+    SimplePlugin plugin = SimplePlugin.newBuilder("test").addContextPropagators(propagator).build();
+
+    WorkerFactoryOptions.Builder builder = WorkerFactoryOptions.newBuilder();
+    ((io.temporal.worker.WorkerPlugin) plugin).configureWorkerFactory(builder);
+
+    assertEquals(Collections.singletonList(propagator), builder.build().getContextPropagators());
+  }
+
   @Test
   public void testAddClientInterceptors() {
     WorkflowClientInterceptor interceptor = new WorkflowClientInterceptorBase() {};
 
@@ -14,6 +14,7 @@
 import io.temporal.testing.TestEnvironmentOptions;
 import io.temporal.testing.TestWorkflowEnvironment;
 import io.temporal.worker.Worker;
+import io.temporal.worker.WorkerFactoryOptions;
 import io.temporal.workflow.shared.TestActivities;
 import io.temporal.workflow.shared.TestWorkflows;
 import java.time.Duration;
@@ -99,6 +100,77 @@ public void testThreadContextPropagation() {
     assertEquals("asynctesting123", result);
   }
 
+  @Test
+  public void testThreadContextPropagationFromWorkerFactoryOptions() {
+    TestEnvironmentOptions options =
+        TestEnvironmentOptions.newBuilder()
+            .setWorkerFactoryOptions(
+                WorkerFactoryOptions.newBuilder()
+                    .setContextPropagators(Collections.singletonList(new TestContextPropagator()))
+                    .build())
+            .build();
+    TestWorkflowEnvironment environment = TestWorkflowEnvironment.newInstance(options);
+    try {
+      Worker worker = environment.newWorker(TASK_QUEUE);
+      worker.registerWorkflowImplementationTypes(FactoryContextPropagationThreadWorkflowImpl.class);
+      environment.start();
+
+      WorkflowOptions workflowOptions =
+          WorkflowOptions.newBuilder().setTaskQueue(TASK_QUEUE).build();
+      TestWorkflows.TestWorkflow1 workflow =
+          environment
+              .getWorkflowClient()
+              .newWorkflowStub(TestWorkflows.TestWorkflow1.class, workflowOptions);
+      assertEquals("testing123", workflow.execute("testing123"));
+    } finally {
+      environment.close();
+    }
+  }
+
+  @Test
+  public void testDuplicateContextPropagatorsAreIgnored() {
+    TestContextPropagator clientPropagator = new TestContextPropagator();
+    TestContextPropagator factoryPropagator =
+        new TestContextPropagator() {
+          @Override
+          public String getName() {
+            return clientPropagator.getName();
+          }
+
+          @Override
+          public Object getCurrentContext() {
+            throw new AssertionError("Duplicate factory context propagator was used");
+          }
+        };
+    TestEnvironmentOptions options =
+        TestEnvironmentOptions.newBuilder()
+            .setWorkflowClientOptions(
+                WorkflowClientOptions.newBuilder()
+                    .setContextPropagators(Collections.singletonList(clientPropagator))
+                    .build())
+            .setWorkerFactoryOptions(
+                WorkerFactoryOptions.newBuilder()
+                    .setContextPropagators(Collections.singletonList(factoryPropagator))
+                    .build())
+            .build();
+    TestWorkflowEnvironment environment = TestWorkflowEnvironment.newInstance(options);
+    try {
+      Worker worker = environment.newWorker(TASK_QUEUE);
+      worker.registerWorkflowImplementationTypes(FactoryContextPropagationThreadWorkflowImpl.class);
+      environment.start();
+
+      WorkflowOptions workflowOptions =
+          WorkflowOptions.newBuilder().setTaskQueue(TASK_QUEUE).build();
+      TestWorkflows.TestWorkflow1 workflow =
+          environment
+              .getWorkflowClient()
+              .newWorkflowStub(TestWorkflows.TestWorkflow1.class, workflowOptions);
+      assertEquals("testing123", workflow.execute("testing123"));
+    } finally {
+      environment.close();
+    }
+  }
+
   @Test
   public void testActivityContextPropagation() {
     Worker worker = testEnvironment.newWorker(TASK_QUEUE);
@@ -334,6 +406,16 @@ private String async() {
     }
   }
 
+  public static class FactoryContextPropagationThreadWorkflowImpl
+      implements TestWorkflows.TestWorkflow1 {
+
+    @Override
+    public String execute(String input) {
+      MDC.put("test", input);
+      return Async.function(() -> MDC.get("test")).get();
+    }
+  }
+
   public static class ContextActivityImpl implements TestActivities.TestActivity1 {
     @Override
     public String execute(String input) {