While loop out of control...maybe? I'm not sure. Trying to track Coroutines progress.

So the developer go back with me and I was on the right track but just doing a few things wrong. I wasn't adding the jobs to the queue right, in terms of making the running or isRunning method work. I also wasn't sure be he cleared it up that this check must be in LateUpdate. Below is the code that works for me. I hope this can help someone else!

 using UnityEngine;
 using UnityEngine.UI;
 using UnityEngine.SceneManagement;
 using System.Collections;
 using System.IO;
 using AssetBundles;
 
 /// <summary>
 /// 
 /// </summary>
 public class NewGameLoadingScene : MonoBehaviour
 {
 
     /// <summary>
     /// Initalizing Variables.
     /// Image for the loading image
     /// Text for loading text (unused by me)
     /// Scenes assetbundle name and scene name
     /// </summary>
     public Image imageComponent;
 
     public Text textComponent;
     public string sceneAssetBundle;
     public string sceneNameTiedToAssetBundle;
 
     private float startTime;
     private float elapsedTime;
     private float framesProcessed;
     private float framesRemaining;
     private float timeLeft;
 
     bool isQueueRunning;
     bool isInitRunning;
     bool isAsyncRunning;
 
     private CM_Job initJob;
     private CM_Job asyncJob;
 
     Scene currentScene;
 
 
     void Awake()
     {
         SetProgress(0);
         startTime = Time.realtimeSinceStartup;
         startTime = Mathf.Round(startTime);
         currentScene = SceneManager.GetActiveScene();
         elapsedTime = Time.realtimeSinceStartup - startTime;
     }
 
     /// <summary>
     /// 
     /// </summary>
     void Start()
     {
 
         if (imageComponent != null)
         {
             imageComponent.type = Image.Type.Filled;
             imageComponent.fillMethod = Image.FillMethod.Horizontal;
             imageComponent.fillAmount = 0f;
         }
        
         if (textComponent != null)
             textComponent.text = "0%";
 
         initJob = CM_Job.Make(Initialize(), "init");
         asyncJob = CM_Job.Make(AsynchronousLoad(sceneAssetBundle, sceneNameTiedToAssetBundle, true), "asyncLoad");
         CM_JobQueue.Global.Enqueue(initJob).Enqueue(asyncJob).Start();
         
         //Debug.Log("<color=red>Current Scene:</color> " + currentScene.name);
     }
 
     void LateUpdate()
     {
         framesProcessed += Time.frameCount/Time.deltaTime * 0.00001f;
         framesRemaining += Mathf.Abs(1 - framesProcessed);
         /* this is based off of:
          * (TimeTaken / framesProcessed) * framesRemaining = timeLeft
          * so we have
          * (10/100) * 200 = 20 Seconds now 10 seconds go past
          * (20/100) * 200 = 40 Seconds left now 10 more seconds and we process 100 more lines
          * (30/200) * 100 = 15 Seconds and now we all see why the copy file dialog jumps from 3 hours to 30 minutes :-)
          * 
          * pulled from http://stackoverflow.com/questions/473355/calculate-time-remaining/473369#473369
          */
         isQueueRunning = CM_JobQueue.Global.running;
         isInitRunning = initJob.running;
         isAsyncRunning = asyncJob.running;
         if (isQueueRunning || isInitRunning || isAsyncRunning)
         {
             
             elapsedTime = (Time.realtimeSinceStartup - startTime);
             //Debug.Log("Frames Processed, Frames Remaining & Elapsed Time: " + framesProcessed + " / " + framesRemaining + " / " + elapsedTime);
             timeLeft += elapsedTime / framesProcessed * framesRemaining * 0.00001f;
             SetProgress(timeLeft);
             //Debug.Log("Time Left Calculation: " + timeLeft);
         }
         if (!isQueueRunning && !isInitRunning && !isAsyncRunning)
         {
             SetProgress(1);
             SceneManager.UnloadSceneAsync(currentScene);
         }
         //Debug.Log("<color=red>Is Any Queue running in LateUpdate?</color> " + isQueueRunning + " " + isInitRunning + " " + isAsyncRunning);
     }
 
     /// <summary>
     /// 
     /// </summary>
     /// <param name="amount"></param>
     public void SetProgress(float amount)
     {
         if (imageComponent != null)
             imageComponent.fillAmount = amount;
 
         if (textComponent != null)
             textComponent.text = (amount * 100).ToString("0") + "%";
     }
 
     /// <summary>
     /// Initalizing the Source URL. The StreamingAssets folder should be the default place
     /// where you're assetbundles are.
     /// </summary>
     void InitializeSourceURL()
     {
         // Use the following code if AssetBundles are embedded in the project for example via StreamingAssets folder etc:
         AssetBundleManager.SetSourceAssetBundleURL("file://" + Application.streamingAssetsPath + "/");
         // Or customize the URL based on your deployment or configuration
         //AssetBundleManager.SetSourceAssetBundleURL("http://www.MyWebsite/MyAssetBundles");
     }
 
     /// <summary>
     /// Initialize the downloading url and AssetBundleManifest object.
     /// </summary>
     /// <returns></returns>
     public IEnumerator Initialize()
     {
         // Don't destroy the game object as we base on it to run the loading script.
         DontDestroyOnLoad(gameObject);
 
         InitializeSourceURL();
 
         // Initialize AssetBundleManifest which loads the AssetBundleManifest object.
         var request = AssetBundleManager.Initialize();
         if (request != null)
         {
             yield return StartCoroutine(request);
         }
         //Debug.Log("<color=red>Is Any Queue running in INITIALIZE?</color> " + isQueueRunning + " " + isInitRunning + " " + isAsyncRunning);
     }
 
     /// <summary>
     /// 
     /// </summary>
     /// <param name="sceneBundle"></param>
     /// <param name="sceneName"></param>
     /// <param name="isAditive"></param>
     /// <returns></returns>
     public IEnumerator AsynchronousLoad(string sceneBundle, string sceneName, bool isAditive)
     {
         AssetBundleLoadOperation request = AssetBundleManager.LoadLevelAsync(sceneBundle, sceneName, isAditive);
         if (request == null)
             yield break;
         yield return StartCoroutine(request);
         //Debug.Log("<color=red>Is Any Queue running in INITIALIZE?</color> " + isQueueRunning + " " + isInitRunning + " " + isAsyncRunning);
     }
 }