diff --git a/packages/sequencer/src/index.ts b/packages/sequencer/src/index.ts
index 7da10194e..0cf5a36d0 100644
--- a/packages/sequencer/src/index.ts
+++ b/packages/sequencer/src/index.ts
@@ -23,6 +23,8 @@ export * from "./worker/worker/FlowTaskWorker";
 export * from "./worker/worker/LocalTaskWorkerModule";
 export * from "./worker/worker/TaskWorkerModule";
 export * from "./worker/worker/WorkerReadyModule";
+export * from "./worker/startup/WorkerRegistrationTask";
+export * from "./worker/startup/CloseWorkerError";
 export * from "./protocol/baselayer/BaseLayer";
 export * from "./protocol/baselayer/MinaBaseLayer";
 export * from "./protocol/baselayer/NoopBaseLayer";
@@ -47,6 +49,10 @@ export * from "./protocol/production/tasks/serializers/RuntimeVerificationKeyAtt
 export * from "./protocol/production/tasks/serializers/StateTransitionParametersSerializer";
 export * from "./protocol/production/tasks/serializers/TransactionProvingTaskParameterSerializer";
 export * from "./protocol/production/tasks/serializers/VerificationKeySerializer";
+export * from "./protocol/production/tasks/compile/CircuitCompileTask";
+export * from "./protocol/production/tasks/compile/ProtocolCompileTask";
+export * from "./protocol/production/tasks/compile/RuntimeCompileTask";
+export * from "./protocol/production/tasks/compile/SettlementCompileTask";
 export * from "./protocol/production/trigger/BlockTrigger";
 export * from "./protocol/production/trigger/ManualBlockTrigger";
 export * from "./protocol/production/trigger/TimedBlockTrigger";
diff --git a/packages/sequencer/src/protocol/production/tasks/CircuitCompilerTask.ts b/packages/sequencer/src/protocol/production/tasks/CircuitCompilerTask.ts
deleted file mode 100644
index 2e14928d8..000000000
--- a/packages/sequencer/src/protocol/production/tasks/CircuitCompilerTask.ts
+++ /dev/null
@@ -1,196 +0,0 @@
-import { inject, injectable, Lifecycle, scoped } from "tsyringe";
-import { Runtime } from "@proto-kit/module";
-import {
-  log,
-  mapSequential,
-  StringKeyOf,
-  ArtifactRecord,
-  CompileRegistry,
-  CompilableModule,
-  safeParseJson,
-  reduceSequential,
-} from "@proto-kit/common";
-import {
-  MandatorySettlementModulesRecord,
-  Protocol,
-  SettlementContractModule,
-  RuntimeVerificationKeyRootService,
-  MandatoryProtocolModulesRecord,
-  type SettlementModulesRecord,
-  BridgingSettlementContractArgs,
-  ContractArgsRegistry,
-} from "@proto-kit/protocol";
-
-import { TaskSerializer } from "../../../worker/flow/Task";
-import { UnpreparingTask } from "../../../worker/flow/UnpreparingTask";
-import { SignedSettlementPermissions } from "../../../settlement/permissions/SignedSettlementPermissions";
-import { ProvenSettlementPermissions } from "../../../settlement/permissions/ProvenSettlementPermissions";
-
-import {
-  ArtifactRecordSerializer,
-  SerializedArtifactRecord,
-} from "./serializers/ArtifactionRecordSerializer";
-
-export type CompilerTaskParams = {
-  existingArtifacts: ArtifactRecord;
-  targets: string[];
-  runtimeVKRoot?: string;
-  isSignedSettlement?: boolean;
-};
-
-@injectable()
-@scoped(Lifecycle.ContainerScoped)
-export class CircuitCompilerTask extends UnpreparingTask<
-  CompilerTaskParams,
-  ArtifactRecord
-> {
-  public name = "compiledCircuit";
-
-  public constructor(
-    @inject("Runtime") protected readonly runtime: Runtime<never>,
-    @inject("Protocol")
-    protected readonly protocol: Protocol<MandatoryProtocolModulesRecord>,
-    private readonly compileRegistry: CompileRegistry,
-    private readonly contractArgsRegistry: ContractArgsRegistry
-  ) {
-    super();
-  }
-
-  public inputSerializer(): TaskSerializer<CompilerTaskParams> {
-    type CompilerTaskParamsJSON = {
-      targets: string[];
-      runtimeVKRoot?: string;
-      existingArtifacts: SerializedArtifactRecord;
-      isSignedSettlement?: boolean;
-    };
-
-    const serializer = new ArtifactRecordSerializer();
-    return {
-      toJSON: (input) =>
-        JSON.stringify({
-          targets: input.targets,
-          runtimeVKRoot: input.runtimeVKRoot,
-          existingArtifacts: serializer.toJSON(input.existingArtifacts),
-          isSignedSettlement: input.isSignedSettlement,
-        } satisfies CompilerTaskParamsJSON),
-      fromJSON: (input) => {
-        const json = safeParseJson<CompilerTaskParamsJSON>(input);
-        return {
-          targets: json.targets,
-          runtimeVKRoot: json.runtimeVKRoot,
-          existingArtifacts: serializer.fromJSON(json.existingArtifacts),
-          isSignedSettlement: json.isSignedSettlement,
-        };
-      },
-    };
-  }
-
-  public resultSerializer(): TaskSerializer<ArtifactRecord> {
-    const serializer = new ArtifactRecordSerializer();
-    return {
-      toJSON: (input) => JSON.stringify(serializer.toJSON(input)),
-      fromJSON: (input) =>
-        serializer.fromJSON(safeParseJson<SerializedArtifactRecord>(input)),
-    };
-  }
-
-  public getSettlementTargets(): Record<string, CompilableModule> {
-    // We only care about the BridgeContract for now - later with caching,
-    // we might want to expand that to all protocol circuits
-    const container = this.protocol.dependencyContainer;
-    if (container.isRegistered("SettlementContractModule")) {
-      const settlementModule = container.resolve<
-        SettlementContractModule<SettlementModulesRecord>
-      >("SettlementContractModule");
-
-      // Needed so that all contractFactory functions are called, because
-      // they set static args on the contracts
-      settlementModule.getContractClasses();
-
-      const moduleNames =
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        settlementModule.moduleNames as StringKeyOf<MandatorySettlementModulesRecord>[];
-
-      const modules = moduleNames.map<[string, CompilableModule]>((name) => [
-        `Settlement.${name}`,
-        settlementModule.resolve(name),
-      ]);
-
-      const sumModule = {
-        compile: async (registry: CompileRegistry) => {
-          await reduceSequential<[string, CompilableModule], ArtifactRecord>(
-            modules,
-            async (record, [moduleName, module]) => {
-              log.info(`Compiling ${moduleName}`);
-              const artifacts = await module.compile(registry);
-              return {
-                ...record,
-                ...artifacts,
-              };
-            },
-            {}
-          );
-        },
-      };
-
-      const combinedModules = [...modules, ["Settlement", sumModule]];
-
-      return Object.fromEntries(combinedModules);
-    }
-    return {};
-  }
-
-  public async compute(input: CompilerTaskParams): Promise<ArtifactRecord> {
-    log.info("Computing VKs");
-
-    this.compileRegistry.addArtifactsRaw(input.existingArtifacts);
-
-    // We need to initialize the VK tree root if we have it, so that
-    // the BlockProver can bake in that root
-    if (input.runtimeVKRoot !== undefined) {
-      this.protocol.dependencyContainer
-        .resolve(RuntimeVerificationKeyRootService)
-        .setRoot(BigInt(input.runtimeVKRoot));
-    }
-
-    if (input.isSignedSettlement !== undefined) {
-      this.contractArgsRegistry.addArgs<BridgingSettlementContractArgs>(
-        "SettlementContract",
-        {
-          signedSettlements: input.isSignedSettlement,
-          // TODO Add distinction between mina and custom tokens
-          BridgeContractPermissions: (input.isSignedSettlement
-            ? new SignedSettlementPermissions()
-            : new ProvenSettlementPermissions()
-          ).bridgeContractMina(),
-        }
-      );
-    }
-
-    // TODO make adaptive
-    const targets: Record<string, CompilableModule> = {
-      runtime: this.runtime,
-      protocol: this.protocol.blockProver,
-      ...this.getSettlementTargets(),
-    };
-
-    const msg = `Compiling targets [${input.targets}]`;
-    log.time(msg);
-    await mapSequential(input.targets, async (target) => {
-      if (target in targets) {
-        await targets[target].compile(this.compileRegistry);
-      } else {
-        log.info(
-          // TODO Is that right? Or should we check that the bridge exists on the sequencer side?
-          `Compile target ${target} not found, skipping`
-        );
-      }
-    });
-    log.timeEnd.info(msg);
-
-    const newEntries = Object.entries(
-      this.compileRegistry.getAllArtifacts()
-    ).filter(([key]) => !(key in input.existingArtifacts));
-    return Object.fromEntries(newEntries);
-  }
-}
diff --git a/packages/sequencer/src/protocol/production/tasks/compile/CircuitCompileTask.ts b/packages/sequencer/src/protocol/production/tasks/compile/CircuitCompileTask.ts
new file mode 100644
index 000000000..b6cdc656c
--- /dev/null
+++ b/packages/sequencer/src/protocol/production/tasks/compile/CircuitCompileTask.ts
@@ -0,0 +1,122 @@
+import {
+  log,
+  mapSequential,
+  ArtifactRecord,
+  CompileRegistry,
+  CompilableModule,
+  safeParseJson,
+} from "@proto-kit/common";
+import {
+  Protocol,
+  RuntimeVerificationKeyRootService,
+  MandatoryProtocolModulesRecord,
+  BridgingSettlementContractArgs,
+  ContractArgsRegistry,
+} from "@proto-kit/protocol";
+
+import { TaskSerializer } from "../../../../worker/flow/Task";
+import { UnpreparingTask } from "../../../../worker/flow/UnpreparingTask";
+import { SignedSettlementPermissions } from "../../../../settlement/permissions/SignedSettlementPermissions";
+import { ProvenSettlementPermissions } from "../../../../settlement/permissions/ProvenSettlementPermissions";
+import {
+  ArtifactRecordSerializer,
+  SerializedArtifactRecord,
+} from "../serializers/ArtifactionRecordSerializer";
+
+export type CompilerTaskParams = {
+  existingArtifacts: ArtifactRecord;
+  runtimeVKRoot?: string;
+  isSignedSettlement?: boolean;
+};
+
+export abstract class CircuitCompileTask extends UnpreparingTask<
+  CompilerTaskParams,
+  ArtifactRecord
+> {
+  protected constructor(
+    protected readonly protocol: Protocol<MandatoryProtocolModulesRecord>,
+    protected readonly compileRegistry: CompileRegistry,
+    protected readonly contractArgsRegistry: ContractArgsRegistry
+  ) {
+    super();
+  }
+
+  public inputSerializer(): TaskSerializer<CompilerTaskParams> {
+    type CompilerTaskParamsJSON = {
+      runtimeVKRoot?: string;
+      existingArtifacts: SerializedArtifactRecord;
+      isSignedSettlement?: boolean;
+    };
+
+    const serializer = new ArtifactRecordSerializer();
+    return {
+      toJSON: (input) =>
+        JSON.stringify({
+          runtimeVKRoot: input.runtimeVKRoot,
+          existingArtifacts: serializer.toJSON(input.existingArtifacts),
+          isSignedSettlement: input.isSignedSettlement,
+        } satisfies CompilerTaskParamsJSON),
+      fromJSON: (input) => {
+        const json = safeParseJson<CompilerTaskParamsJSON>(input);
+        return {
+          runtimeVKRoot: json.runtimeVKRoot,
+          existingArtifacts: serializer.fromJSON(json.existingArtifacts),
+          isSignedSettlement: json.isSignedSettlement,
+        };
+      },
+    };
+  }
+
+  public resultSerializer(): TaskSerializer<ArtifactRecord> {
+    const serializer = new ArtifactRecordSerializer();
+    return {
+      toJSON: (input) => JSON.stringify(serializer.toJSON(input)),
+      fromJSON: (input) =>
+        serializer.fromJSON(safeParseJson<SerializedArtifactRecord>(input)),
+    };
+  }
+
+  public abstract getTargets(): Promise<CompilableModule[]>;
+
+  public async compute(input: CompilerTaskParams): Promise<ArtifactRecord> {
+    log.info("Computing VKs");
+
+    this.compileRegistry.addArtifactsRaw(input.existingArtifacts);
+
+    // We need to initialize the VK tree root if we have it, so that
+    // the BlockProver can bake in that root
+    if (input.runtimeVKRoot !== undefined) {
+      this.protocol.dependencyContainer
+        .resolve(RuntimeVerificationKeyRootService)
+        .setRoot(BigInt(input.runtimeVKRoot));
+    }
+
+    if (input.isSignedSettlement !== undefined) {
+      this.contractArgsRegistry.addArgs<BridgingSettlementContractArgs>(
+        "SettlementContract",
+        {
+          signedSettlements: input.isSignedSettlement,
+          // TODO Add distinction between mina and custom tokens
+          BridgeContractPermissions: (input.isSignedSettlement
+            ? new SignedSettlementPermissions()
+            : new ProvenSettlementPermissions()
+          ).bridgeContractMina(),
+        }
+      );
+    }
+
+    const targets = await this.getTargets();
+
+    const msg = `Compiling targets ${this.name}`;
+    log.time(msg);
+    await mapSequential(targets, async (target) => {
+      await target.compile(this.compileRegistry);
+    });
+    log.timeEnd.info(msg);
+
+    const newEntries = Object.entries(
+      this.compileRegistry.getAllArtifacts()
+    ).filter(([key]) => !(key in input.existingArtifacts));
+    return Object.fromEntries(newEntries);
+  }
+}
diff --git a/packages/sequencer/src/protocol/production/tasks/compile/ProtocolCompileTask.ts b/packages/sequencer/src/protocol/production/tasks/compile/ProtocolCompileTask.ts
new file mode 100644
index 000000000..fba628ca9
--- /dev/null
+++ b/packages/sequencer/src/protocol/production/tasks/compile/ProtocolCompileTask.ts
@@ -0,0 +1,28 @@
+import { inject, injectable, Lifecycle, scoped } from "tsyringe";
+import { CompilableModule, CompileRegistry } from "@proto-kit/common";
+import {
+  ContractArgsRegistry,
+  MandatoryProtocolModulesRecord,
+  Protocol,
+} from "@proto-kit/protocol";
+
+import { CircuitCompileTask } from "./CircuitCompileTask";
+
+@injectable()
+@scoped(Lifecycle.ContainerScoped)
+export class ProtocolCompileTask extends CircuitCompileTask {
+  public name = "compile-protocol";
+
+  public constructor(
+    @inject("Protocol")
+    protocol: Protocol<MandatoryProtocolModulesRecord>,
+    compileRegistry: CompileRegistry,
+    contractArgsRegistry: ContractArgsRegistry
+  ) {
+    super(protocol, compileRegistry, contractArgsRegistry);
+  }
+
+  public async getTargets(): Promise<CompilableModule[]> {
+    return [this.protocol.blockProver];
+  }
+}
diff --git a/packages/sequencer/src/protocol/production/tasks/compile/RuntimeCompileTask.ts b/packages/sequencer/src/protocol/production/tasks/compile/RuntimeCompileTask.ts
new file mode 100644
index 000000000..3002c9137
--- /dev/null
+++ b/packages/sequencer/src/protocol/production/tasks/compile/RuntimeCompileTask.ts
@@ -0,0 +1,30 @@
+import { inject, injectable, Lifecycle, scoped } from "tsyringe";
+import { CompilableModule, CompileRegistry } from "@proto-kit/common";
+import { Runtime } from "@proto-kit/module";
+import {
+  ContractArgsRegistry,
+  MandatoryProtocolModulesRecord,
+  Protocol,
+} from "@proto-kit/protocol";
+
+import { CircuitCompileTask } from "./CircuitCompileTask";
+
+@injectable()
+@scoped(Lifecycle.ContainerScoped)
+export class RuntimeCompileTask extends CircuitCompileTask {
+  public name = "compile-runtime";
+
+  public constructor(
+    @inject("Runtime") protected readonly runtime: Runtime<never>,
+    @inject("Protocol")
+    protocol: Protocol<MandatoryProtocolModulesRecord>,
+    compileRegistry: CompileRegistry,
+    contractArgsRegistry: ContractArgsRegistry
+  ) {
+    super(protocol, compileRegistry, contractArgsRegistry);
+  }
+
+  public async getTargets(): Promise<CompilableModule[]> {
+    return [this.runtime];
+  }
+}
diff --git a/packages/sequencer/src/protocol/production/tasks/compile/SettlementCompileTask.ts b/packages/sequencer/src/protocol/production/tasks/compile/SettlementCompileTask.ts
new file mode 100644
index 000000000..9fbfa1168
--- /dev/null
+++ b/packages/sequencer/src/protocol/production/tasks/compile/SettlementCompileTask.ts
@@ -0,0 +1,98 @@
+import { inject, injectable, Lifecycle, scoped } from "tsyringe";
+import {
+  ArtifactRecord,
+  ChildVerificationKeyService,
+  CompilableModule,
+  CompileRegistry,
+  log,
+  reduceSequential,
+  StringKeyOf,
+} from "@proto-kit/common";
+import {
+  ContractArgsRegistry,
+  MandatoryProtocolModulesRecord,
+  MandatorySettlementModulesRecord,
+  Protocol,
+  SettlementContractModule,
+  SettlementModulesRecord,
+} from "@proto-kit/protocol";
+
+import { BatchProducerModule } from "../../BatchProducerModule";
+
+import { CircuitCompileTask } from "./CircuitCompileTask";
+
+@injectable()
+@scoped(Lifecycle.ContainerScoped)
+export class SettlementCompileTask extends CircuitCompileTask {
+  public name = "compile-settlement";
+
+  public constructor(
+    @inject("Protocol")
+    protocol: Protocol<MandatoryProtocolModulesRecord>,
+    compileRegistry: CompileRegistry,
+    contractArgsRegistry: ContractArgsRegistry,
+    @inject("BatchProducerModule", { isOptional: true })
+    batchProducerModule: BatchProducerModule | undefined,
+    private readonly childVkService: ChildVerificationKeyService
+  ) {
+    super(protocol, compileRegistry, contractArgsRegistry);
+
+    const container = this.protocol.dependencyContainer;
+    if (
+      !container.isRegistered("SettlementContractModule") &&
+      // Disable this check for the sequencer
+      batchProducerModule === undefined
+    ) {
+      throw new Error(
+        "SettlementContractModule not configured but SettlementCompilerTask is - fix the configuration"
+      );
+    }
+  }
+
+  public getSettlementTargets(): CompilableModule[] {
+    // We only care about the BridgeContract for now - later with caching,
+    // we might want to expand that to all protocol circuits
+    const container = this.protocol.dependencyContainer;
+    const settlementModule = container.resolve<
+      SettlementContractModule<SettlementModulesRecord>
+    >("SettlementContractModule");
+
+    // Needed so that all contractFactory functions are called, because
+    // they set static args on the contracts
+    settlementModule.getContractClasses();
+
+    const moduleNames =
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      settlementModule.moduleNames as StringKeyOf<MandatorySettlementModulesRecord>[];
+
+    const modules = moduleNames.map<[string, CompilableModule]>((name) => [
+      `Settlement.${name}`,
+      settlementModule.resolve(name),
+    ]);
+
+    const sumModule = {
+      compile: async (registry: CompileRegistry) => {
+        await reduceSequential<[string, CompilableModule], ArtifactRecord>(
+          modules,
+          async (record, [moduleName, module]) => {
+            log.info(`Compiling ${moduleName}`);
+            const artifacts = await module.compile(registry);
+            return {
+              ...record,
+              ...artifacts,
+            };
+          },
+          {}
+        );
+      },
+    };
+
+    return [sumModule];
+  }
+
+  public async getTargets(): Promise<CompilableModule[]> {
+    this.childVkService.setCompileRegistry(this.compileRegistry);
+
+    return this.getSettlementTargets();
+  }
+}
diff --git a/packages/sequencer/src/sequencer/SequencerStartupModule.ts b/packages/sequencer/src/sequencer/SequencerStartupModule.ts
index 603835f7a..2e37e8bf1 100644
--- a/packages/sequencer/src/sequencer/SequencerStartupModule.ts
+++ b/packages/sequencer/src/sequencer/SequencerStartupModule.ts
@@ -12,17 +12,20 @@ import {
   ChildVerificationKeyService,
   CompileRegistry,
   AreProofsEnabled,
+  CompileArtifact,
 } from "@proto-kit/common";
 
 import { Flow, FlowCreator } from "../worker/flow/Flow";
-import { WorkerRegistrationFlow } from "../worker/worker/startup/WorkerRegistrationFlow";
-import {
-  CircuitCompilerTask,
-  CompilerTaskParams,
-} from "../protocol/production/tasks/CircuitCompilerTask";
+import { WorkerRegistrationFlow } from "../worker/startup/WorkerRegistrationFlow";
 import { VerificationKeyService } from "../protocol/runtime/RuntimeVerificationKeyService";
 import type { MinaBaseLayer } from "../protocol/baselayer/MinaBaseLayer";
 import { NoopBaseLayer } from "../protocol/baselayer/NoopBaseLayer";
+import { RuntimeCompileTask } from "../protocol/production/tasks/compile/RuntimeCompileTask";
+import { ProtocolCompileTask } from "../protocol/production/tasks/compile/ProtocolCompileTask";
+import { SettlementCompileTask } from "../protocol/production/tasks/compile/SettlementCompileTask";
+import { CompilerTaskParams } from "../protocol/production/tasks/compile/CircuitCompileTask";
+import { Task } from "../worker/flow/Task";
+import { SettlementModule } from "../settlement/SettlementModule";
 
 import { SequencerModule, sequencerModule } from "./builder/SequencerModule";
 import { Closeable, closeable } from "./builder/Closeable";
@@ -37,7 +40,9 @@ export class SequencerStartupModule
     private readonly flowCreator: FlowCreator,
     @inject("Protocol")
     private readonly protocol: Protocol<MandatoryProtocolModulesRecord>,
-    private readonly compileTask: CircuitCompilerTask,
+    private readonly runtimeCompilerTask: RuntimeCompileTask,
+    private readonly protocolCompilerTask: ProtocolCompileTask,
+    private readonly settlementCompilerTask: SettlementCompileTask,
     private readonly verificationKeyService: VerificationKeyService,
     private readonly registrationFlow: WorkerRegistrationFlow,
     private readonly compileRegistry: CompileRegistry,
@@ -45,28 +50,34 @@ export class SequencerStartupModule
     private readonly baseLayer: MinaBaseLayer | undefined,
     @inject("AreProofsEnabled")
     private readonly areProofsEnabled: AreProofsEnabled,
-    private readonly contractArgsRegistry: ContractArgsRegistry
+    private readonly contractArgsRegistry: ContractArgsRegistry,
+    @inject("SettlementModule", { isOptional: true })
+    private readonly settlementModule: SettlementModule | undefined
   ) {
     super();
   }
 
   private async pushCompileTask(
     flow: Flow<{}>,
+    task: Task<CompilerTaskParams, ArtifactRecord>,
     payload: CompilerTaskParams
   ): Promise<ArtifactRecord> {
     return await flow.withFlow<ArtifactRecord>(async (res, rej) => {
-      await flow.pushTask(this.compileTask, payload, async (result) => {
+      await flow.pushTask(task, payload, async (result) => {
         res(result);
       });
     });
   }
 
   public async compileRuntime(flow: Flow<{}>) {
-    const artifacts = await this.pushCompileTask(flow, {
-      existingArtifacts: {},
-      targets: ["runtime"],
-      runtimeVKRoot: undefined,
-    });
+    const artifacts = await this.pushCompileTask(
+      flow,
+      this.runtimeCompilerTask,
+      {
+        existingArtifacts: {},
+        runtimeVKRoot: undefined,
+      }
+    );
 
     // Init runtime VK tree
     await this.verificationKeyService.initializeVKTree(artifacts);
@@ -82,51 +93,34 @@ export class SequencerStartupModule
     return root;
   }
 
-  private async compileProtocolAndBridge(
-    flow: Flow<{}>,
-    runtimeVkTreeRoot: bigint,
-    isSignedSettlement?: boolean
-  ) {
-    // Can happen in parallel
-    type ParallelResult = {
-      protocol?: ArtifactRecord;
-      bridge?: ArtifactRecord;
-    };
-
+  private async compileBridge(flow: Flow<{}>, isSignedSettlement?: boolean) {
     const result = await flow.withFlow<ArtifactRecord>(async (res, rej) => {
-      const results: ParallelResult = {};
-
-      const resolveIfPossible = () => {
-        const { bridge, protocol } = results;
-        if (bridge !== undefined && protocol !== undefined) {
-          res({ ...protocol, ...bridge });
-        }
-      };
-
       await flow.pushTask(
-        this.compileTask,
+        this.settlementCompilerTask,
         {
-          existingArtifacts: {},
-          targets: ["protocol"],
-          runtimeVKRoot: runtimeVkTreeRoot.toString(),
+          existingArtifacts: this.compileRegistry.getAllArtifacts(),
+          runtimeVKRoot: undefined,
+          isSignedSettlement,
         },
-        async (protocolResult) => {
-          results.protocol = protocolResult;
-          resolveIfPossible();
+        async (bridgeResult) => {
+          res(bridgeResult);
         }
       );
+    });
+    this.compileRegistry.addArtifactsRaw(result);
+    return result;
+  }
 
+  private async compileProtocol(flow: Flow<{}>, runtimeVkTreeRoot: bigint) {
+    const result = await flow.withFlow<ArtifactRecord>(async (res, rej) => {
       await flow.pushTask(
-        this.compileTask,
+        this.protocolCompilerTask,
         {
-          existingArtifacts: {},
-          targets: ["Settlement.BridgeContract"],
-          runtimeVKRoot: undefined,
-          isSignedSettlement,
+          existingArtifacts: this.compileRegistry.getAllArtifacts(),
+          runtimeVKRoot: runtimeVkTreeRoot.toString(),
         },
-        async (bridgeResult) => {
-          results.bridge = bridgeResult;
-          resolveIfPossible();
+        async (protocolResult) => {
+          res(protocolResult);
         }
       );
     });
@@ -159,26 +153,32 @@ export class SequencerStartupModule
 
     const root = await this.compileRuntime(flow);
 
-    const protocolBridgeArtifacts = await this.compileProtocolAndBridge(
-      flow,
-      root,
-      isSignedSettlement
-    );
+    await this.compileProtocol(flow, root);
 
-    log.info("Protocol circuits compiled");
+    let bridgeVk: CompileArtifact | undefined = undefined;
 
-    // Init BridgeContract vk for settlement contract
-    const bridgeVk = protocolBridgeArtifacts.BridgeContract;
-    if (bridgeVk !== undefined) {
-      // TODO Inject CompileRegistry directly
-      this.contractArgsRegistry.addArgs<BridgingSettlementContractArgs>(
-        "SettlementContract",
-        {
-          BridgeContractVerificationKey: bridgeVk.verificationKey,
-        }
+    if (this.settlementModule !== undefined) {
+      const bridgeArtifacts = await this.compileBridge(
+        flow,
+        isSignedSettlement
       );
+
+      // TODO Why is this not in SettlementStartupModule?
+      // Init BridgeContract vk for settlement contract
+      bridgeVk = bridgeArtifacts.BridgeContract;
+      if (bridgeVk !== undefined) {
+        // TODO Inject CompileRegistry directly
+        this.contractArgsRegistry.addArgs<BridgingSettlementContractArgs>(
+          "SettlementContract",
+          {
+            BridgeContractVerificationKey: bridgeVk.verificationKey,
+          }
+        );
+      }
     }
 
+    log.info("Protocol circuits compiled");
+
     await this.registrationFlow.start({
       runtimeVerificationKeyRoot: root,
       bridgeContractVerificationKey: bridgeVk?.verificationKey,
diff --git a/packages/sequencer/src/sequencer/SettlementStartupModule.ts b/packages/sequencer/src/sequencer/SettlementStartupModule.ts
index 1936fb3c1..bdc3bee6e 100644
--- a/packages/sequencer/src/sequencer/SettlementStartupModule.ts
+++ b/packages/sequencer/src/sequencer/SettlementStartupModule.ts
@@ -7,7 +7,7 @@ import {
 } from "@proto-kit/common";
 
 import { FlowCreator } from "../worker/flow/Flow";
-import { CircuitCompilerTask } from "../protocol/production/tasks/CircuitCompilerTask";
+import { SettlementCompileTask } from "../protocol/production/tasks/compile/SettlementCompileTask";
 
 @injectable()
 export class SettlementStartupModule {
@@ -15,7 +15,7 @@ export class SettlementStartupModule {
   public constructor(
     private readonly compileRegistry: CompileRegistry,
     private readonly flowCreator: FlowCreator,
-    private readonly compileTask: CircuitCompilerTask
+    private readonly compileTask: SettlementCompileTask
   ) {}
 
   // TODO Compile only individual contracts - this however runs into the
@@ -29,7 +29,6 @@ export class SettlementStartupModule {
         this.compileTask,
         {
           existingArtifacts: this.compileRegistry.getAllArtifacts(),
-          targets: ["Settlement"],
           runtimeVKRoot: undefined,
         },
         async (result) => res(result)
diff --git a/packages/sequencer/src/worker/worker/startup/CloseWorkerError.ts b/packages/sequencer/src/worker/startup/CloseWorkerError.ts
similarity index 100%
rename from packages/sequencer/src/worker/worker/startup/CloseWorkerError.ts
rename to packages/sequencer/src/worker/startup/CloseWorkerError.ts
diff --git a/packages/sequencer/src/worker/worker/startup/WorkerRegistrationFlow.ts b/packages/sequencer/src/worker/startup/WorkerRegistrationFlow.ts
similarity index 90%
rename from packages/sequencer/src/worker/worker/startup/WorkerRegistrationFlow.ts
rename to packages/sequencer/src/worker/startup/WorkerRegistrationFlow.ts
index 17340300e..be6133a06 100644
--- a/packages/sequencer/src/worker/worker/startup/WorkerRegistrationFlow.ts
+++ b/packages/sequencer/src/worker/startup/WorkerRegistrationFlow.ts
@@ -1,8 +1,8 @@
 import { injectable } from "tsyringe";
 import { log } from "@proto-kit/common";
 
-import { Closeable } from "../../../sequencer/builder/Closeable";
-import { FlowCreator } from "../../flow/Flow";
+import { Closeable } from "../../sequencer/builder/Closeable";
+import { FlowCreator } from "../flow/Flow";
 
 import {
   WorkerRegistrationTask,
diff --git a/packages/sequencer/src/worker/worker/startup/WorkerRegistrationTask.ts b/packages/sequencer/src/worker/startup/WorkerRegistrationTask.ts
similarity index 91%
rename from packages/sequencer/src/worker/worker/startup/WorkerRegistrationTask.ts
rename to packages/sequencer/src/worker/startup/WorkerRegistrationTask.ts
index 3d4474717..370d95b5e 100644
--- a/packages/sequencer/src/worker/worker/startup/WorkerRegistrationTask.ts
+++ b/packages/sequencer/src/worker/startup/WorkerRegistrationTask.ts
@@ -15,18 +15,18 @@ import {
 } from "@proto-kit/protocol";
 import { VerificationKey } from "o1js";
 
-import { Task } from "../../flow/Task";
-import { AbstractStartupTask } from "../../flow/AbstractStartupTask";
+import { Task } from "../flow/Task";
+import { AbstractStartupTask } from "../flow/AbstractStartupTask";
 import {
   VerificationKeyJSON,
   VerificationKeySerializer,
-} from "../../../protocol/production/tasks/serializers/VerificationKeySerializer";
+} from "../../protocol/production/tasks/serializers/VerificationKeySerializer";
 import {
   ArtifactRecordSerializer,
   SerializedArtifactRecord,
-} from "../../../protocol/production/tasks/serializers/ArtifactionRecordSerializer";
-import { SignedSettlementPermissions } from "../../../settlement/permissions/SignedSettlementPermissions";
-import { ProvenSettlementPermissions } from "../../../settlement/permissions/ProvenSettlementPermissions";
+} from "../../protocol/production/tasks/serializers/ArtifactionRecordSerializer";
+import { SignedSettlementPermissions } from "../../settlement/permissions/SignedSettlementPermissions";
+import { ProvenSettlementPermissions } from "../../settlement/permissions/ProvenSettlementPermissions";
 
 import { CloseWorkerError } from "./CloseWorkerError";
 
diff --git a/packages/sequencer/src/worker/worker/LocalTaskWorkerModule.ts b/packages/sequencer/src/worker/worker/LocalTaskWorkerModule.ts
index 85fa05663..715ad045b 100644
--- a/packages/sequencer/src/worker/worker/LocalTaskWorkerModule.ts
+++ b/packages/sequencer/src/worker/worker/LocalTaskWorkerModule.ts
@@ -23,16 +23,18 @@ import { SettlementProvingTask } from "../../settlement/tasks/SettlementProvingT
 import { Task } from "../flow/Task";
 import { TaskQueue } from "../queue/TaskQueue";
 import { StateTransitionTask } from "../../protocol/production/tasks/StateTransitionTask";
-import { CircuitCompilerTask } from "../../protocol/production/tasks/CircuitCompilerTask";
 import { closeable } from "../../sequencer/builder/Closeable";
 import { StateTransitionReductionTask } from "../../protocol/production/tasks/StateTransitionReductionTask";
 import { TransactionProvingTask } from "../../protocol/production/tasks/TransactionProvingTask";
 import { BlockReductionTask } from "../../protocol/production/tasks/BlockReductionTask";
 import { TransactionReductionTask } from "../../protocol/production/tasks/TransactionReductionTask";
+import { WorkerRegistrationTask } from "../startup/WorkerRegistrationTask";
+import { RuntimeCompileTask } from "../../protocol/production/tasks/compile/RuntimeCompileTask";
+import { ProtocolCompileTask } from "../../protocol/production/tasks/compile/ProtocolCompileTask";
+import { SettlementCompileTask } from "../../protocol/production/tasks/compile/SettlementCompileTask";
 
 import { FlowTaskWorker } from "./FlowTaskWorker";
 import { TaskWorkerModule } from "./TaskWorkerModule";
-import { WorkerRegistrationTask } from "./startup/WorkerRegistrationTask";
 
 // Temporary workaround against the compiler emitting
 // import("common/dist") inside the library artifacts
@@ -139,8 +141,9 @@ export class VanillaTaskWorkerModules {
       TransactionReductionTask,
       BlockReductionTask,
       NewBlockTask,
-      CircuitCompilerTask,
       WorkerRegistrationTask,
+      RuntimeCompileTask,
+      ProtocolCompileTask,
     } satisfies TaskWorkerModulesRecord;
   }
 
@@ -148,6 +151,7 @@ export class VanillaTaskWorkerModules {
     return {
       ...VanillaTaskWorkerModules.withoutSettlement(),
       SettlementProvingTask,
+      SettlementCompileTask,
     } satisfies TaskWorkerModulesRecord;
   }
 
@@ -161,8 +165,10 @@ export class VanillaTaskWorkerModules {
       NewBlockTask: {},
       StateTransitionReductionTask: {},
       SettlementProvingTask: {},
-      CircuitCompilerTask: {},
       WorkerRegistrationTask: {},
+      RuntimeCompileTask: {},
+      ProtocolCompileTask: {},
+      SettlementCompileTask: {},
     } satisfies ModulesConfig<
       ReturnType<typeof VanillaTaskWorkerModules.allTasks>
     >;
diff --git a/packages/sequencer/test/integration/MempoolTxRemoved.test.ts b/packages/sequencer/test/integration/MempoolTxRemoved.test.ts
index 02fae71f5..ace902990 100644
--- a/packages/sequencer/test/integration/MempoolTxRemoved.test.ts
+++ b/packages/sequencer/test/integration/MempoolTxRemoved.test.ts
@@ -27,6 +27,7 @@ describe("mempool removal mechanism", () => {
   let trigger: ManualBlockTrigger;
 
   const createAppChain = async () => {
+    log.setLevel("TRACE");
     const app = AppChain.from({
       Sequencer: Sequencer.from(testingSequencerModules({})),
       Protocol: Protocol.from(Protocol.defaultModules()),
diff --git a/packages/sequencer/test/settlement/Settlement-only.ts b/packages/sequencer/test/settlement/Settlement-only.ts
index c894bfbcf..ddae5a758 100644
--- a/packages/sequencer/test/settlement/Settlement-only.ts
+++ b/packages/sequencer/test/settlement/Settlement-only.ts
@@ -39,6 +39,7 @@ import {
   SettlementModule,
   SettlementProvingTask,
   VanillaTaskWorkerModules,
+  SettlementCompileTask,
 } from "../../src";
 
 import { Withdrawals } from "./mocks/Withdrawals";
@@ -80,6 +81,7 @@ export const settlementOnlyTestFn = (
         },
         {
           SettlementProvingTask,
+          SettlementCompileTask,
         }
       )
     );