@@ -333,10 +333,25 @@
 	(begin
 	  (hash-table-set! *runs:denoise* key currtime)
 	  #t)
 	#f)))
 
+(define *last-test-launch* 0)
+(define *too-soon-delays* (make-hash-table))
+
+;; to-soon delay, when matching event happened in less than dseconds delay wseconds
+;;
+(define (runs:too-soon-delay key dseconds wseconds)
+  (let* ((last-time (hash-table-ref/default *too-soon-delays* key #f)))
+    (if (and last-time
+	     (< (- (current-seconds) last-time) dseconds))
+	(begin
+	  (if (runs:lownoise (conc "too-soon-delay"key) 60)
+	      (debug:print-info 2 *default-log-port* "Polling throttle for "key))
+	  (thread-sleep! wseconds)))
+    (hash-table-set! *too-soon-delays* key (current-seconds))))
+
 (define (runs:can-run-more-tests runsdat run-id jobgroup max-concurrent-jobs)
 
   ;; Take advantage of a good place to exit if running the one-pass methodology
   (if (and (> (runs:dat-can-run-more-tests-count runsdat) 20)
 	   (args:get-arg "-one-pass"))
@@ -1308,10 +1323,11 @@
       ;; we are going to reset all the counters for test retries by setting a new hash table
       ;; this means they will increment only when nothing can be run
       (set! *max-tries-hash* (make-hash-table))
       
       (run:test run-id run-info keyvals runname test-record flags #f test-registry all-tests-registry runsdat testdat)
+      (set! *last-test-launch* (current-seconds))
       (runs:incremental-print-results run-id)
       (hash-table-set! test-registry (db:test-make-full-name test-name item-path) 'running)
       (runs:shrink-can-run-more-tests-count runsdat)  ;; DELAY TWEAKER (still needed?)
       ;; (thread-sleep! *global-delta*)
       (if (or (not (null? tal))(not (null? reg)))
@@ -1676,11 +1692,16 @@
 		  (debug:print-info 2 *default-log-port* "Excessively fast loop, delaying 1/2 second"))
 	      (thread-sleep! 0.5)))
 	(set! *last-loop-time-ms* (current-milliseconds))
      
 	(runs:dat-regfull-set! runsdat regfull)
-    
+
+
+	(if (> (- (current-seconds) *last-test-launch*) 5)        ;; be pretty aggressive for five seconds after
+	    (runs:too-soon-delay (conc "loop delay " hed) 1 0.6)    ;; starting a test then apply more delay
+	    (runs:too-soon-delay (conc "loop delay " hed) 1 0.1)) 
+	
 	(if (> num-running 0)
             (set! last-time-some-running (current-seconds)))
 
         (if (> (current-seconds)(+ last-time-some-running (or (configf:lookup *configdat* "setup" "give-up-waiting") 36000)))
             (hash-table-set! *max-tries-hash* tfullname (+ (hash-table-ref/default *max-tries-hash* tfullname 0) 1)))
@@ -1925,11 +1946,11 @@
     (rmt:set-var (conc "lunch-complete-" run-id) "yes")  
         
     ;; now *if* -run-wait we wait for all tests to be done
     ;; Now wait for any RUNNING tests to complete (if in run-wait mode)
     ;; (if (runs:dat-load-mgmt-function runsdat)((runs:dat-load-mgmt-function runsdat)))
-    (thread-sleep! 10) ;; I think there is a race condition here. Let states/statuses settle
+    (thread-sleep! 0.1) ;; I think there is a race condition here. Let states/statuses settle
     
     (let wait-loop ((num-running      (rmt:get-count-tests-running-for-run-id run-id))
 		    (prev-num-running 0))
       ;; (debug:print-info 13 *default-log-port* "num-running=" num-running ", prev-num-running=" prev-num-running)
       (if (and (or (args:get-arg "-run-wait")