@@ -1304,6 +1304,17 @@ const EnvironmentSchema = z
     RUN_ENGINE_DEQUEUE_DISABLED_WORKER_QUEUES: z.string().optional(),
     // JSON map of worker-group IDs to allowed v2 subscriptions. Unlisted groups are denied.
     RUN_ENGINE_WORKER_QUEUE_SUBSCRIPTIONS: WorkerQueueSubscriptionPolicyEnv,
+    // Comma-separated worker-group IDs that carry container and compute consumers side by side. A
+    // MICROVM group must be listed here to consume the container lanes its allowlist names.
+    RUN_ENGINE_MIXED_RUNTIME_WORKER_GROUPS: z
+      .string()
+      .default("")
+      .transform((raw) =>
+        raw
+          .split(",")
+          .map((id) => id.trim())
+          .filter(Boolean)
+      ),
     RUN_ENGINE_MASTER_QUEUE_CONSUMERS_INTERVAL_MS: z.coerce.number().int().default(1000),
     // Off by default. Enable on a single service (e.g. the engine worker) so only one
     // instance reports worker queue length, rather than every replica.
 
@@ -43,6 +43,17 @@ export function isOrgMigrated({
   return hashBucket(orgId) < pct;
 }
 
+/**
+ * Whether a run may go on an `any` lane. Either runtime takes an `any` item, so only a run that
+ * compute can start qualifies: a compute-enabled org and a deployment with a template.
+ */
+export function allowsAnyCompat({
+  templateKey,
+  ...decision
+}: MigrationDecisionInput & { templateKey: string | null | undefined }): boolean {
+  return !!templateKey && isOrgMigrated(decision);
+}
+
 type ResolveInput = MigrationDecisionInput & {
   baseWorkerQueue: string | undefined;
   baseEnableFastPath: boolean;
@@ -57,7 +68,7 @@ type ResolveInput = MigrationDecisionInput & {
 /**
  * Produce the target descriptor `{ workerQueue, region, enableFastPath }` for a
  * run. When the org is migrated and the region has a compute backing, the queue
- * and fast-path setting come from the MICROVM backing group; `region` is the geo
+ * and fast-path setting come from the compute backing group; `region` is the geo
  * either way. Same-geo swap (us-east-1 -> us-east-1-next): any explicit placement
  * is a geography preference, honored by staying in-region. Applied after region
  * resolution, mirroring the scheduled-split. An environment compat of compute or container
@@ -81,6 +92,8 @@ export function resolveComputeMigration({
   enableFastPath: boolean;
   /** Set when the missing template key kept a migrated run on the base queue. */
   templateFallback?: true;
+  /** Set when the run moved to the backing, which may be the base queue's own mixed group. */
+  compute?: true;
 } {
   const passthrough = { workerQueue: baseWorkerQueue, region, enableFastPath: baseEnableFastPath };
   if (baseWorkerQueue === undefined) return passthrough;
@@ -94,5 +107,10 @@ export function resolveComputeMigration({
         : isOrgMigrated(decision);
   if (!migrated) return passthrough;
   if (!templateKey) return { ...passthrough, templateFallback: true };
-  return { workerQueue: backing.workerQueue, region, enableFastPath: backing.enableFastPath };
+  return {
+    workerQueue: backing.workerQueue,
+    region,
+    enableFastPath: backing.enableFastPath,
+    compute: true,
+  };
 }
@@ -1,5 +1,8 @@
 import { describe, expect, it } from "vitest";
-import { resolveComputeMigration } from "~/runEngine/concerns/computeMigration.server";
+import {
+  allowsAnyCompat,
+  resolveComputeMigration,
+} from "~/runEngine/concerns/computeMigration.server";
 import {
   environmentWorkerQueueOverride,
   workerQueueForBirth,
@@ -16,6 +19,7 @@ const assignment = {
   splitEnabled: true,
   workerGroups: [{ masterQueue: "us-east-1-next", workloadType: "MICROVM" as const }],
   rootTriggerSource: "api",
+  anyCompatAllowed: true,
 };
 
 describe("workerQueueForBirth", () => {
@@ -242,18 +246,21 @@ describe("per-environment worker queue overrides", () => {
         environmentId,
         environmentType,
       });
+      const decision = {
+        planType: "free",
+        orgId: "org_x",
+        orgFeatureFlags,
+        flags: { computeMigrationEnabled: migrationEnabled, computeMigrationFreePercentage: 100 },
+        templateKey,
+      };
       const migrated = resolveComputeMigration({
+        ...decision,
         baseWorkerQueue: "us-east-1",
         baseEnableFastPath: false,
         region: "us-east-1",
         backing,
-        planType: "free",
-        orgId: "org_x",
-        orgFeatureFlags,
-        flags: { computeMigrationEnabled: migrationEnabled, computeMigrationFreePercentage: 100 },
         envType: environmentType,
         environmentCompat: environmentOverride.compat,
-        templateKey,
       });
       const workerQueue = workerQueueForBirth({
         workerQueue: migrated.workerQueue!,
@@ -266,6 +273,7 @@ describe("per-environment worker queue overrides", () => {
         workerGroups,
         rootTriggerSource: "api",
         templateFallback: migrated.templateFallback,
+        anyCompatAllowed: allowsAnyCompat(decision),
       });
       return { workerQueue, enableFastPath: migrated.enableFastPath };
     }
@@ -341,6 +349,7 @@ describe("per-environment worker queue overrides", () => {
           splitEnabled: false,
           workerGroups,
           rootTriggerSource: "api",
+          anyCompatAllowed: true,
         });
       expect(birth(true)).toBe("us-east-1:v2:ondemand:fresh:container:stable");
       expect(birth(false)).toBe("us-east-1-next");
@@ -372,10 +381,54 @@ describe("per-environment worker queue overrides", () => {
           splitEnabled: false,
           workerGroups: [{ masterQueue: "eu-central-1", workloadType: "CONTAINER" }],
           rootTriggerSource: "api",
+          anyCompatAllowed: true,
         })
       ).toBe("eu-central-1:v2:ondemand:fresh:compute:stable");
     });
 
+    const anyOrg = { [FEATURE_FLAG.workerQueueCompatibility]: "any" };
+    const anyStaging = {
+      [FEATURE_FLAG.workerQueueEnvironmentOverrides]: { STAGING: { compat: "any" } },
+    };
+    it.each([
+      { migrationEnabled: false, templateKey: "a".repeat(64), compat: "container" },
+      { migrationEnabled: false, templateKey: null, compat: "container" },
+      { migrationEnabled: true, templateKey: null, compat: "container" },
+      { migrationEnabled: true, templateKey: "a".repeat(64), compat: "any" },
+    ])(
+      "gives the any lane only to a migrated org's keyed deployment (migrated=$migrationEnabled, key=$templateKey)",
+      ({ migrationEnabled, templateKey, compat }) => {
+        for (const orgFeatureFlags of [anyOrg, anyStaging]) {
+          expect(trigger({ orgFeatureFlags, migrationEnabled, templateKey }).workerQueue).toBe(
+            `us-east-1:v2:ondemand:fresh:${compat}:stable`
+          );
+        }
+      }
+    );
+
+    it("puts a migrated org's keyless any-compat canary run on the stable container channel", () => {
+      const canaryOrg = { [FEATURE_FLAG.workerQueueChannel]: "canary" };
+      const canaryStaging = {
+        [FEATURE_FLAG.workerQueueEnvironmentOverrides]: { STAGING: { channel: "canary" } },
+      };
+      const anyCanaryStaging = {
+        [FEATURE_FLAG.workerQueueEnvironmentOverrides]: {
+          STAGING: { compat: "any", channel: "canary" },
+        },
+      };
+      for (const orgFeatureFlags of [
+        { ...anyOrg, ...canaryOrg },
+        { ...anyStaging, ...canaryOrg },
+        { ...anyOrg, ...canaryStaging },
+        anyCanaryStaging,
+      ]) {
+        expect(trigger({ orgFeatureFlags, migrationEnabled: true, templateKey: null })).toEqual({
+          workerQueue: "us-east-1:v2:ondemand:fresh:container:stable",
+          enableFastPath: false,
+        });
+      }
+    });
+
     it("leaves a channel-only override to the org's migration decision", () => {
       const canaryStaging = {
         [FEATURE_FLAG.workerQueueEnvironmentOverrides]: { STAGING: { channel: "canary" } },
 
@@ -50,6 +50,8 @@ export function workerQueueForBirth({
   workerGroups,
   rootTriggerSource,
   templateFallback,
+  compute,
+  anyCompatAllowed,
 }: {
   workerQueue: string;
   region: string | undefined;
@@ -62,6 +64,10 @@ export function workerQueueForBirth({
   rootTriggerSource: string | undefined;
   /** The run stays off compute because its deployment has no template key. */
   templateFallback?: boolean;
+  /** The run moved to its region's compute backing, so it defaults to compute in a mixed group. */
+  compute?: boolean;
+  /** The org is compute-enabled and the deployment has a template, so either runtime can run it. */
+  anyCompatAllowed: boolean;
 }): string {
   if (envType === "DEVELOPMENT") {
     return workerQueue;
@@ -73,7 +79,8 @@ export function workerQueueForBirth({
     return workerQueueForRun({ workerQueue, rootTriggerSource, splitEnabled });
   }
 
-  const defaultCompatibility = group.workloadType === "MICROVM" ? "compute" : "container";
+  const defaultCompatibility =
+    compute || group.workloadType === "MICROVM" ? "compute" : "container";
   const compatibility = FeatureFlagCatalog[FEATURE_FLAG.workerQueueCompatibility].safeParse(
     environmentOverride.compat ??
       orgFeatureFlags?.[FEATURE_FLAG.workerQueueCompatibility] ??
@@ -82,7 +89,9 @@ export function workerQueueForBirth({
   const channel = FeatureFlagCatalog[FEATURE_FLAG.workerQueueChannel].safeParse(
     environmentOverride.channel ?? orgFeatureFlags?.[FEATURE_FLAG.workerQueueChannel] ?? "stable"
   );
-  const compat = compatibility.success ? compatibility.data : defaultCompatibility;
+  const parsed = compatibility.success ? compatibility.data : defaultCompatibility;
+  // An `any` item goes to whichever runtime takes it first, so only a run compute can start is one.
+  const compat = parsed === "any" && !anyCompatAllowed ? "container" : parsed;
   // Match the dequeue fallback: container consumers take only the stable channel.
   const keylessOnContainers = templateFallback && compat === "container";
   const assignment = formatWorkerQueue({