       c)))
 
 (defn- convert-from-legacy [scenarios]
-  ;Skip conversion if it matches new schema already
-  (if-not (check [schema/RunnableScenario] scenarios)
-    scenarios
-    (let [request->step (fn [request]
-                          (-> request
-                              (assoc :request (convert-legacy-fn request))
-                              (dissoc :fn :http)))]
-      (validate [schema/RunnableScenario]
-                (map (fn [scenario]
-                       (-> scenario
-                           (update :requests #(map request->step %))
-                           (rename-keys {:requests :steps})
-                           (dissoc :concurrency :weight)))
-                     scenarios)))))
+  (let [request->step (fn [request]
+                        (-> request
+                            (assoc :request (convert-legacy-fn request))
+                            (dissoc :fn :http)))]
+    (map (fn [scenario]
+           (-> scenario
+               (update :requests #(map request->step %))
+               (rename-keys {:requests :steps})
+               (dissoc :concurrency :weight)))
+         scenarios)))
 
 (defn- run-scenario [options scenario]
   (print-scenario-info scenario)

  (run-scenarios (assoc options :runner (choose-runner scenarios
                                                       concurrency
                                                       options))
                 (weighted-scenarios (range concurrency) scenarios)))



               (close! results)))
    results))

(defn run-scenarios [options scenarios convert-from-legacy?]
  (println "Running simulation with" (runner-info (:runner options)))
  (let [simulation-start (local-time/local-now)
        sent-requests (atom 0)
        runnable-scenarios (validate [schema/RunnableScenario] (if convert-from-legacy?
                                                                 (convert-from-legacy scenarios)
                                                                 scenarios))
        run-scenario-with-opts (partial run-scenario
                                        (assoc options
                                               :simulation-start simulation-start
                                               :sent-requests sent-requests))
        responses (async/merge (map run-scenario-with-opts runnable-scenarios))
        results (async/chan)]
    (go-loop []
             (if-let [result (<! responses)]
