If you haven't already, take a look at the interval creation operator. It could be just what you're searching for. I experimented with this operator and came up with the following code:

Execute(sessionId: string, projectName: string, operations: string[]) {
  this.service
    .Execute(sessionId, projectName, this.operations)
    .pipe(
      first(),
      tap((executionResult) => {
        localStorage.setItem('executionResult', executionResult);
        this.executionResult = executionResult;
      }),
      switchMap(() => interval(2000)),
      takeWhile(() => !['Completed', 'Failed'].includes(this.executionStatus)),
      tap(() => {
        this.loadingService.showSpinner({
          text: 'Processing operations...',
        });
      }),
      switchMap(() => this.service.getExecutionStatus(this.executionResult))
    )
    .subscribe((status) => {
      this.executionStatus = status;
      this.loadingService.hideSpinner();
      console.log(status);
      console.log(this.executionStatus);

      if (this.executionStatus === 'Completed') {
        this.messageService.add({
          severity: Severity.Success,
          summary: 'Operations executed successfully',
          detail: 'Via MessageService',
        });
        this.messageService.clear();
      }
    });
}

1. It is recommended to avoid nested subscriptions and instead utilize higher order mapping operators such as switchMap.

2. Instead of relying on traditional JS statements like for or while, consider using RxJS functions like interval or timer for polling purposes.

3. Utilize the tap operator to handle side effects, such as storing data in local storage.

import { Observable, timer } from 'rxjs';
import { tap, finalize, switchMap, takeWhile } from 'rxjs/operators';

POLL_INTERVAL = 2000;
instanceStatus: string = "Initialized";
instanceName:string = "InstanceName";

this.Launch(sample, sample, sample).pipe(
  switchMap((instanceName: any) => 
    timer(0, POLL_INTERVAL).pipe(                                         // <-- start immediately and poll every 'n' secs
      switchMap(() => this.service.getEngineStatus(instanceName)),
      takeWhile((instanceStatus: any) => instanceStatus === 'Succeeded'), // <-- stop poll when status !== 'Succeeded'
      finalize(() => {                                                    // <-- run when polling stops
        this.messageService.add({
          severity: Severity.Success,
          summary: 'Fault modeling completed',
          detail: 'Via MessageService'
        });
        this.messageService.clear();
      })
    )
  ).subscribe({
    next: (instanceStatus: any) => this.instanceStatus = instanceStatus
  });
)

Launch(sessionId: string, projectName: string, f: string[]): Observable<any> {
  return this.service.Launch(sessionId, projectName, this.f).pipe(
    first(),
    tap((instanceName: any) => {
      localStorage.setItem('instanceName', instanceName);
      this.instanceName = instanceName;
    })
  );
}

Update (Thanks to @Liam):

1. do has been replaced by the tap operator.
2. The placement of .subscribe() within the pipe() function was incorrect and should be at the end after all operators. Please adjust the code accordingly.

Upon my observation, it seems that implementing something along these lines could lead you towards finding a solution.

The critical aspect here is the timer triggering a value every 2 seconds as long as status !== "Succeeded". Once status === "Succeeded", setting the second argument in takeWhile to true allows for the final emission prior to closing the timer (eliminating further checks every 2 seconds).

Everything else flows from this point.

launch(sessionId: string, projectName: string, f: string[]): void {
  this.service.launch(sessionId, projectName, f).pipe(

    first(),
    tap(instanceName => {
      localStorage.setItem('instanceName', instanceName);
      this.instanceName = instanceName;
    }),
    switchMap((instanceName:string) => timer(0,2000).pipe(
      exhaustMap(_ => this.service.getEngineStatus(instanceName).pipe(
        first()
      )),
      takeWhile((status:string) => status !== "Succeeded", true),
      map(status => ({instanceName, status}))
    ))

  ).subscribe(({instanceName, status}) => {
    this.loadingService.showSpinner({ text: 'Modeling is running...' });
    if (status === "Succeeded") {
      this.messageService.add({ 
        severity: Severity.Success, 
        summary: 'Fault modeling completed', 
        detail: 'Via MessageService' 
      });
      this.messageService.clear();
    }
  });
}

Update

Below is code that achieves your goal but is completely self-contained. It's not based on your code since I can't execute/test code without access.

The timers in the service simulate a delay between request and response.

type Status = "Succeeded" | "Other"

interface Service {
  // Pretending direct access to privateStatus isn't possible
  privateStatus: Status,
  launch: (sessionId: string) => Observable<string>,
  getStatus: (instanceName: string) => Observable<Status>
}

class ArbitraryClass {

  service: Service;
  readonly PING_INTERVAL = 2000; 

  constructor(){
    this.service = {
      privateStatus: "Other",
      launch: (sessionId: string) => timer(8000).pipe(
        mapTo(""),
        tap(status => this.service.privateStatus = "Succeeded"),
        filter(_ => false),
        startWith(`Hello ${sessionId}`)
      ),
      getStatus: _ => timer(500).pipe(mapTo(this.service.privateStatus))
    }
  }

  arbitraryInit(sessionId: string) {

    // Launch session, then query the status at each ping interval 
    // and display the results in the console.
    this.service.launch(sessionId).pipe(
      switchMap(instanceName => timer(0,this.PING_INTERVAL).pipe(
        exhaustMap(_ => this.service.getStatus(instanceName)),
        takeWhile(status => status !== "Succeeded", true),
        map(status => ({instanceName, status}))
      ))
    ).subscribe(console.log);

  }
  
}

new ArbitraryClass().arbitraryInit("ABCD_1234");

Output in the console when I ran this:

{ instanceName: 'Hello ABCD_1234', status: 'Other' }
{ instanceName: 'Hello ABCD_1234', status: 'Other' }
{ instanceName: 'Hello ABCD_1234', status: 'Other' }
{ instanceName: 'Hello ABCD_1234', status: 'Other' }
{ instanceName: 'Hello ABCD_1234', status: 'Succeeded' }