diff --git a/pipeline-model-definition/src/main/resources/org/jenkinsci/plugins/pipeline/modeldefinition/ModelInterpreter.groovy b/pipeline-model-definition/src/main/resources/org/jenkinsci/plugins/pipeline/modeldefinition/ModelInterpreter.groovy
index 7fd7aee5b..a8f62ea1c 100644
--- a/pipeline-model-definition/src/main/resources/org/jenkinsci/plugins/pipeline/modeldefinition/ModelInterpreter.groovy
+++ b/pipeline-model-definition/src/main/resources/org/jenkinsci/plugins/pipeline/modeldefinition/ModelInterpreter.groovy
@@ -31,6 +31,7 @@ import hudson.Launcher
 import hudson.model.Result
 import org.jenkinsci.plugins.pipeline.StageStatus
 import org.jenkinsci.plugins.pipeline.modeldefinition.Messages
+import org.jenkinsci.plugins.pipeline.modeldefinition.agent.DeclarativeAgentScript2
 import org.jenkinsci.plugins.pipeline.modeldefinition.model.*
 import org.jenkinsci.plugins.pipeline.modeldefinition.options.DeclarativeOption
 import org.jenkinsci.plugins.pipeline.modeldefinition.steps.CredentialWrapper
@@ -82,7 +83,7 @@ class ModelInterpreter implements Serializable {
                                 // the whole pipeline and don't want firstError to be set.
                                 firstError = null
                                 toolsBlock(root.tools, root.agent, null) {
-                                    firstError = evaluateSequentialStages(root, root.stages, firstError, null, restartedStage, null).call()
+                                    firstError = evaluateSequentialStages(root, root.stages, firstError, null, restartedStage, null)
 
                                     // Execute post-build actions now that we've finished all parallel.
                                     try {
@@ -148,50 +149,47 @@ class ModelInterpreter implements Serializable {
      * @param restartedStageName the name of the stage we're restarting at. Null if this is not a restarted build or this is
      *     called from a nested stage.
      * @param skippedReason Possibly null reason the container for the stages was skipped.
-     * @return A closure to execute
      */
     def evaluateSequentialStages(Root root, Stages stages, Throwable firstError, Stage parent, String restartedStageName,
                                  SkippedStageReason skippedReason) {
-        return {
-            try {
-                boolean skippedForRestart = restartedStageName != null
-                stages.stages.each { thisStage ->
-                    if (skippedForRestart) {
-                        // Check if we're skipping for restart but are now on the stage we're supposed to restart on.
-                        if (thisStage.name == restartedStageName) {
-                            // If so, set skippedForRestart to false, and if the skippedReason is for restart, wipe that out too.
-                            skippedForRestart = false
-                            if (skippedReason instanceof SkippedStageReason.Restart) {
-                                skippedReason = null
-                            }
-                        } else {
-                            // If we skipped for restart and this isn't the restarted name, create a new reason.
-                            skippedReason = new SkippedStageReason.Restart(thisStage.name, restartedStageName)
-                        }
-                    }
-                    try {
-                        evaluateStage(root, thisStage.agent ?: root.agent, thisStage, firstError, parent, skippedReason).call()
-                    } catch (Throwable e) {
-                        Utils.markStageFailedAndContinued(thisStage.name)
-                        if (firstError == null) {
-                            firstError = e
+        try {
+            boolean skippedForRestart = restartedStageName != null
+            stages.stages.each { thisStage ->
+                if (skippedForRestart) {
+                    // Check if we're skipping for restart but are now on the stage we're supposed to restart on.
+                    if (thisStage.name == restartedStageName) {
+                        // If so, set skippedForRestart to false, and if the skippedReason is for restart, wipe that out too.
+                        skippedForRestart = false
+                        if (skippedReason instanceof SkippedStageReason.Restart) {
+                            skippedReason = null
                         }
+                    } else {
+                        // If we skipped for restart and this isn't the restarted name, create a new reason.
+                        skippedReason = new SkippedStageReason.Restart(thisStage.name, restartedStageName)
                     }
-                    if (skippedForRestart) {
-                        Utils.markStartAndEndNodesInStageAsNotExecuted(thisStage.name)
+                }
+                try {
+                    evaluateStage(root, thisStage.agent ?: root.agent, thisStage, firstError, parent, skippedReason)
+                } catch (Throwable e) {
+                    Utils.markStageFailedAndContinued(thisStage.name)
+                    if (firstError == null) {
+                        firstError = e
                     }
                 }
-            } finally {
-                // And finally, run the post stage steps if this was a parallel parent.
-                if (skippedReason == null && parent != null &&
-                    root.hasSatisfiedConditions(parent.post, script.getProperty("currentBuild"), parent, firstError)) {
-                    Utils.logToTaskListener("Post stage")
-                    firstError = runPostConditions(parent.post, parent.agent ?: root.agent, firstError, parent.name)
+                if (skippedForRestart) {
+                    Utils.markStartAndEndNodesInStageAsNotExecuted(thisStage.name)
                 }
             }
-
-            return firstError
+        } finally {
+            // And finally, run the post stage steps if this was a parallel parent.
+            if (skippedReason == null && parent != null &&
+                root.hasSatisfiedConditions(parent.post, script.getProperty("currentBuild"), parent, firstError)) {
+                Utils.logToTaskListener("Post stage")
+                firstError = runPostConditions(parent.post, parent.agent ?: root.agent, firstError, parent.name)
+            }
         }
+
+        return firstError
     }
 
     /**
@@ -208,11 +206,13 @@ class ModelInterpreter implements Serializable {
         def parallelStages = [:]
         thisStage?.parallel?.stages?.each { content ->
             if (skippedReason != null) {
-                parallelStages.put(content.name,
-                    evaluateStage(root, parentAgent, content, firstError, thisStage, skippedReason.cloneWithNewStage(content.name)))
+                parallelStages.put(content.name, {
+                    evaluateStage(root, parentAgent, content, firstError, thisStage, skippedReason.cloneWithNewStage(content.name))
+                })
             } else {
-                parallelStages.put(content.name,
-                    evaluateStage(root, thisStage.agent ?: parentAgent, content, firstError, thisStage, null))
+                parallelStages.put(content.name, {
+                    evaluateStage(root, thisStage.agent ?: parentAgent, content, firstError, thisStage, null)
+                })
             }
         }
         if (!parallelStages.isEmpty() && ( thisStage.failFast || root.options?.options?.get("parallelsAlwaysFailFast") != null) ) {
@@ -238,61 +238,58 @@ class ModelInterpreter implements Serializable {
      * @param firstError An error that's already occurred earlier in the build. Can be null.
      * @param parent The possible parent stage, defaults to null.
      * @param skippedReason Possibly null reason this stage's parent, and therefore itself, is skipped.
-     * @return
      */
     def evaluateStage(Root root, Agent parentAgent, Stage thisStage, Throwable firstError, Stage parent,
                       SkippedStageReason skippedReason) {
-        return {
-            script.stage(thisStage.name) {
-                try {
-                    if (skippedReason != null) {
-                        skipStage(root, parentAgent, thisStage, firstError, skippedReason, parent).call()
-                    } else if (firstError != null) {
-                        skippedReason = new SkippedStageReason.Failure(thisStage.name)
-                        skipStage(root, parentAgent, thisStage, firstError, skippedReason, parent).call()
-                    } else if (skipUnstable(root.options)) {
-                        skippedReason = new SkippedStageReason.Unstable(thisStage.name)
-                        skipStage(root, parentAgent, thisStage, firstError, skippedReason, parent).call()
-                    } else {
-                        // if this a is a matrix generated stage, evaluate the matrix axis values first
-                        // These are literals that guaranteed not to depend on other variables
-                        // Users will expect them to be available at all times in a particular cell in a matrix.
-                        withEnvBlock(thisStage.getMatrixCellEnvVars(script)) {
-
-                            def whenEvaluator = new WhenEvaluator(thisStage.when)
-
-                            if (whenEvaluator.passedOrNotEvaluatedBeforeOptions()) {
-                                inWrappers(thisStage.options?.wrappers) {
-                                    if (whenEvaluator.passedOrNotEvaluatedBeforeInput()) {
-                                        stageInput(thisStage.input) {
-                                            if (thisStage?.parallel != null) {
-                                                if (whenEvaluator.passedOrNotEvaluated()) {
-                                                    withCredentialsBlock(thisStage.environment) {
-                                                        withEnvBlock(thisStage.getEnvVars(script)) {
-                                                            script.parallel(getParallelStages(root, parentAgent, thisStage, firstError, null))
-                                                        }
+        script.stage(thisStage.name) {
+            try {
+                if (skippedReason != null) {
+                    skipStage(root, parentAgent, thisStage, firstError, skippedReason, parent)
+                } else if (firstError != null) {
+                    skippedReason = new SkippedStageReason.Failure(thisStage.name)
+                    skipStage(root, parentAgent, thisStage, firstError, skippedReason, parent)
+                } else if (skipUnstable(root.options)) {
+                    skippedReason = new SkippedStageReason.Unstable(thisStage.name)
+                    skipStage(root, parentAgent, thisStage, firstError, skippedReason, parent)
+                } else {
+                    // if this a is a matrix generated stage, evaluate the matrix axis values first
+                    // These are literals that guaranteed not to depend on other variables
+                    // Users will expect them to be available at all times in a particular cell in a matrix.
+                    withEnvBlock(thisStage.getMatrixCellEnvVars(script)) {
+
+                        def whenEvaluator = new WhenEvaluator(thisStage.when)
+
+                        if (whenEvaluator.passedOrNotEvaluatedBeforeOptions()) {
+                            inWrappers(thisStage.options?.wrappers) {
+                                if (whenEvaluator.passedOrNotEvaluatedBeforeInput()) {
+                                    stageInput(thisStage.input) {
+                                        if (thisStage?.parallel != null) {
+                                            if (whenEvaluator.passedOrNotEvaluated()) {
+                                                withCredentialsBlock(thisStage.environment) {
+                                                    withEnvBlock(thisStage.getEnvVars(script)) {
+                                                        script.parallel(getParallelStages(root, parentAgent, thisStage, firstError, null))
                                                     }
                                                 }
-                                            } else {
-                                                if (whenEvaluator.passedOrNotEvaluatedBeforeAgent()) {
-                                                    inDeclarativeAgent(thisStage, root, thisStage.agent) {
-                                                        if (whenEvaluator.passedOrNotEvaluated()) {
-                                                            withCredentialsBlock(thisStage.environment) {
-                                                                withEnvBlock(thisStage.getEnvVars(script)) {
-                                                                    toolsBlock(thisStage.tools, thisStage.agent ?: root.agent, parent?.tools ?: root.tools) {
-                                                                        if (thisStage?.stages) {
-                                                                            def nestedError = evaluateSequentialStages(root, thisStage.stages, firstError,
-                                                                                                                       thisStage, null, null).call()
-
-                                                                            // Propagate any possible error from the sequential stages
-                                                                            // as if it were an error thrown directly.
-                                                                            if (nestedError != null) {
-                                                                                throw nestedError
-                                                                            }
-                                                                        } else {
-                                                                            // Execute the actual stage and potential post-stage actions
-                                                                            executeSingleStage(root, thisStage, parentAgent)
+                                            }
+                                        } else {
+                                            if (whenEvaluator.passedOrNotEvaluatedBeforeAgent()) {
+                                                inDeclarativeAgent(thisStage, root, thisStage.agent) {
+                                                    if (whenEvaluator.passedOrNotEvaluated()) {
+                                                        withCredentialsBlock(thisStage.environment) {
+                                                            withEnvBlock(thisStage.getEnvVars(script)) {
+                                                                toolsBlock(thisStage.tools, thisStage.agent ?: root.agent, parent?.tools ?: root.tools) {
+                                                                    if (thisStage?.stages) {
+                                                                        def nestedError = evaluateSequentialStages(root, thisStage.stages, firstError,
+                                                                                                                    thisStage, null, null)
+
+                                                                        // Propagate any possible error from the sequential stages
+                                                                        // as if it were an error thrown directly.
+                                                                        if (nestedError != null) {
+                                                                            throw nestedError
                                                                         }
+                                                                    } else {
+                                                                        // Execute the actual stage and potential post-stage actions
+                                                                        executeSingleStage(root, thisStage, parentAgent)
                                                                     }
                                                                 }
                                                             }
@@ -304,85 +301,77 @@ class ModelInterpreter implements Serializable {
                                     }
                                 }
                             }
-                            if (!whenEvaluator.passed) {
-                                skippedReason = new SkippedStageReason.When(thisStage.name)
-                                skipStage(root, parentAgent, thisStage, firstError, skippedReason, parent).call()
-                            }
                         }
-                    }
-                } catch (Throwable e) {
-                    Utils.markStageFailedAndContinued(thisStage.name)
-                    if (firstError == null) {
-                        firstError = e
-                    }
-                } finally {
-                    // And finally, run the post stage steps if this was a parallel parent.
-                    if (skippedReason == null &&
-                        root.hasSatisfiedConditions(thisStage.post, script.getProperty("currentBuild"), thisStage, firstError) &&
-                            thisStage?.parallel != null) {
-                        Utils.logToTaskListener("Post stage")
-                        firstError = runPostConditions(thisStage.post, thisStage.agent ?: parentAgent, firstError, thisStage.name)
+                        if (!whenEvaluator.passed) {
+                            skippedReason = new SkippedStageReason.When(thisStage.name)
+                            skipStage(root, parentAgent, thisStage, firstError, skippedReason, parent)
+                        }
                     }
                 }
-
-                if (firstError != null) {
-                    throw firstError
+            } catch (Throwable e) {
+                Utils.markStageFailedAndContinued(thisStage.name)
+                if (firstError == null) {
+                    firstError = e
+                }
+            } finally {
+                // And finally, run the post stage steps if this was a parallel parent.
+                if (skippedReason == null &&
+                    root.hasSatisfiedConditions(thisStage.post, script.getProperty("currentBuild"), thisStage, firstError) &&
+                        thisStage?.parallel != null) {
+                    Utils.logToTaskListener("Post stage")
+                    firstError = runPostConditions(thisStage.post, thisStage.agent ?: parentAgent, firstError, thisStage.name)
                 }
             }
+
+            if (firstError != null) {
+                throw firstError
+            }
         }
     }
 
     def stageInput(StageInput input, Closure body) {
         if (input != null) {
-            return {
-                def submitted = script.input(message: input.message, id: input.id, ok: input.ok, submitter: input.submitter,
-                    submitterParameter: input.submitterParameter, parameters: input.parameters)
-                if (input.parameters.isEmpty() && input.submitterParameter == null) {
-                    // No parameters, so just proceed
-                    body.call()
-                } else {
-                    def inputEnv = []
-                    if (submitted instanceof Map) {
-                        // Multiple parameters!
-                        inputEnv = submitted.collect { k, v -> "${k}=${v}" }
-                    } else if (input.submitterParameter != null) {
-                        // Single parameter, it's the submitter.
-                        inputEnv = ["${input.submitterParameter}=${submitted}"]
-                    } else if (input.parameters.size() == 1) {
-                        // One defined parameter, so we know its name.
-                        inputEnv = ["${input.parameters.first().name}=${submitted}"]
-                    }
-                    script.withEnv(inputEnv) {
-                        body.call()
-                    }
+            def submitted = script.input(message: input.message, id: input.id, ok: input.ok, submitter: input.submitter,
+                submitterParameter: input.submitterParameter, parameters: input.parameters)
+            if (input.parameters.isEmpty() && input.submitterParameter == null) {
+                // No parameters, so just proceed
+                body.call()
+            } else {
+                def inputEnv = []
+                if (submitted instanceof Map) {
+                    // Multiple parameters!
+                    inputEnv = submitted.collect { k, v -> "${k}=${v}" }
+                } else if (input.submitterParameter != null) {
+                    // Single parameter, it's the submitter.
+                    inputEnv = ["${input.submitterParameter}=${submitted}"]
+                } else if (input.parameters.size() == 1) {
+                    // One defined parameter, so we know its name.
+                    inputEnv = ["${input.parameters.first().name}=${submitted}"]
                 }
-            }.call()
+                script.withEnv(inputEnv, body)
+            }
         } else {
-            return {
-                body.call()
-            }.call()
+            body.call()
         }
     }
 
     def skipStage(Root root, Agent parentAgent, Stage thisStage, Throwable firstError, SkippedStageReason reason,
                   Stage parentStage) {
-        return {
-            Utils.logToTaskListener(reason.message)
-            def stepContextFlowNodeId = getFlowNodeId();
-            Utils.markStageWithTag(thisStage.name, stepContextFlowNodeId, StageStatus.TAG_NAME, reason.stageStatus)
-            if (thisStage?.parallel != null) {
-                Map<String, Closure> parallelToSkip = getParallelStages(root, parentAgent, thisStage, firstError, reason)
-                script.parallel(parallelToSkip)
-                if (reason instanceof SkippedStageReason.Restart) {
-                    parallelToSkip.keySet().each { k -> Utils.markStartAndEndNodesInStageAsNotExecuted(k) }
-                }
-            } else if (thisStage?.stages != null) {
-                String restartedStage = null
-                if (reason instanceof SkippedStageReason.Restart) {
-                    restartedStage = reason.restartedStage
-                }
-                evaluateSequentialStages(root, thisStage.stages, firstError, thisStage, restartedStage, reason).call()
+        Utils.logToTaskListener(reason.message)
+        def stepContextFlowNodeId = getFlowNodeId();
+        Utils.markStageWithTag(thisStage.name, stepContextFlowNodeId, StageStatus.TAG_NAME, reason.stageStatus)
+        if (thisStage?.parallel != null) {
+            Map<String, Closure> parallelToSkip = getParallelStages(root, parentAgent, thisStage, firstError, reason)
+            script.parallel(parallelToSkip)
+            if (reason instanceof SkippedStageReason.Restart) {
+                parallelToSkip.keySet().each { k -> Utils.markStartAndEndNodesInStageAsNotExecuted(k) }
+            }
+        } else if (thisStage?.stages != null) {
+            String restartedStage = null
+            if (reason instanceof SkippedStageReason.Restart) {
+                restartedStage = reason.restartedStage
             }
+            evaluateSequentialStages(root, thisStage.stages, firstError, thisStage, restartedStage, reason)
         }
     }
 
@@ -397,21 +386,19 @@ class ModelInterpreter implements Serializable {
      * @throws Exception
      */
     def catchRequiredContextForNode(Agent agent, Closure body) throws Exception {
-        return {
-            try {
-                body.call()
-            } catch (MissingContextVariableException e) {
-                if (FilePath.class == e.type || Launcher.class == e.type) {
-                    if (!agent.hasAgent()) {
-                        script.error(Messages.ModelInterpreter_NoNodeContext())
-                    } else {
-                        throw e
-                    }
+        try {
+            body.call()
+        } catch (MissingContextVariableException e) {
+            if (FilePath.class == e.type || Launcher.class == e.type) {
+                if (!agent.hasAgent()) {
+                    script.error(Messages.ModelInterpreter_NoNodeContext())
                 } else {
                     throw e
                 }
+            } else {
+                throw e
             }
-        }.call()
+        }
     }
 
     @Deprecated
@@ -440,15 +427,9 @@ class ModelInterpreter implements Serializable {
                     throw new IllegalArgumentException( Messages.ModelInterpreter_EnvironmentVariableFailed(k) )
                 }
             }.findAll { it != null}
-            return {
-                script.withEnv(evaledEnv) {
-                    body.call()
-                }
-            }.call()
+            script.withEnv(evaledEnv, body)
         } else {
-            return {
-                body.call()
-            }.call()
+            body.call()
         }
     }
 
@@ -478,15 +459,9 @@ class ModelInterpreter implements Serializable {
 
         if (!creds.isEmpty()) {
             List<Map<String, Object>> parameters = createWithCredentialsParameters(creds)
-            return {
-                script.withCredentials(parameters) {
-                    body.call()
-                }
-            }.call()
+            script.withCredentials(parameters, body)
         } else {
-            return {
-                body.call()
-            }.call()
+            body.call()
         }
     }
 
@@ -541,15 +516,9 @@ class ModelInterpreter implements Serializable {
                 toolEnv = actualToolsInstall(toolsList)
             }
 
-            return {
-                script.withEnv(toolEnv) {
-                    body.call()
-                }
-            }.call()
+            script.withEnv(toolEnv, body)
         } else {
-            return {
-                body.call()
-            }.call()
+            body.call()
         }
     }
 
@@ -589,18 +558,19 @@ class ModelInterpreter implements Serializable {
             }
         }
         if (agent == null) {
-            return {
-                body.call()
-            }.call()
+            body.call()
         } else {
             def declarativeAgent = agent.getDeclarativeAgent(root, context)
             if (declarativeAgent == null) {
                 script.error 'Unrecognized agent type'
                 return null
             }
-            return declarativeAgent.getScript(script).run {
-                body.call()
-            }.call()
+            def script = declarativeAgent.getScript(script)
+            if (script instanceof DeclarativeAgentScript2) {
+                script.run(body)
+            } else {
+                script.run(body).call()
+            }
         }
     }
 
@@ -617,13 +587,9 @@ class ModelInterpreter implements Serializable {
      */
     def inWrappers(Map<String,Object> wrappers, Closure body) {
         if (wrappers != null) {
-            return {
-                recursiveWrappers(wrappers.keySet().toList(), wrappers, body)
-            }.call()
+            recursiveWrappers(wrappers.keySet().toList(), wrappers, body)
         } else {
-            return {
-                body.call()
-            }.call()
+            body.call()
         }
     }
 
@@ -636,25 +602,19 @@ class ModelInterpreter implements Serializable {
      */
     def recursiveWrappers(List<String> wrapperNames, Map<String,Object> wrappers, Closure body) {
         if (wrapperNames.isEmpty()) {
-            return {
-                body.call()
-            }.call()
+            body.call()
         } else {
             def thisWrapper = wrapperNames.remove(0)
 
             def wrapperArgs = wrappers.get(thisWrapper)
             if (wrapperArgs != null) {
-                return {
-                    script."${thisWrapper}"(wrapperArgs) {
-                        recursiveWrappers(wrapperNames, wrappers, body)
-                    }
-                }.call()
+                script."${thisWrapper}"(wrapperArgs) {
+                    recursiveWrappers(wrapperNames, wrappers, body)
+                }
             } else {
-                return {
-                    script."${thisWrapper}"() {
-                        recursiveWrappers(wrapperNames, wrappers, body)
-                    }
-                }.call()
+                script."${thisWrapper}"() {
+                    recursiveWrappers(wrapperNames, wrappers, body)
+                }
             }
         }
     }
diff --git a/pipeline-model-definition/src/main/resources/org/jenkinsci/plugins/pipeline/modeldefinition/agent/impl/AnyScript.groovy b/pipeline-model-definition/src/main/resources/org/jenkinsci/plugins/pipeline/modeldefinition/agent/impl/AnyScript.groovy
index a67ccf2f9..64ea27edf 100644
--- a/pipeline-model-definition/src/main/resources/org/jenkinsci/plugins/pipeline/modeldefinition/agent/impl/AnyScript.groovy
+++ b/pipeline-model-definition/src/main/resources/org/jenkinsci/plugins/pipeline/modeldefinition/agent/impl/AnyScript.groovy
@@ -26,21 +26,19 @@
 package org.jenkinsci.plugins.pipeline.modeldefinition.agent.impl
 
 import org.jenkinsci.plugins.pipeline.modeldefinition.agent.CheckoutScript
-import org.jenkinsci.plugins.pipeline.modeldefinition.agent.DeclarativeAgentScript
+import org.jenkinsci.plugins.pipeline.modeldefinition.agent.DeclarativeAgentScript2
 import org.jenkinsci.plugins.workflow.cps.CpsScript
 
-class AnyScript extends DeclarativeAgentScript<Any> {
+class AnyScript extends DeclarativeAgentScript2<Any> {
 
     AnyScript(CpsScript s, Any a) {
         super(s, a)
     }
 
     @Override
-    Closure run(Closure body) {
-        return {
-            script.node {
-                CheckoutScript.doCheckout(script, describable, null, body).call()
-            }
+    void run(Closure body) {
+        script.node {
+            CheckoutScript.doCheckout2(script, describable, null, body)
         }
     }
 }
diff --git a/pipeline-model-definition/src/main/resources/org/jenkinsci/plugins/pipeline/modeldefinition/agent/impl/LabelScript.groovy b/pipeline-model-definition/src/main/resources/org/jenkinsci/plugins/pipeline/modeldefinition/agent/impl/LabelScript.groovy
index 745b6021d..e18277c07 100644
--- a/pipeline-model-definition/src/main/resources/org/jenkinsci/plugins/pipeline/modeldefinition/agent/impl/LabelScript.groovy
+++ b/pipeline-model-definition/src/main/resources/org/jenkinsci/plugins/pipeline/modeldefinition/agent/impl/LabelScript.groovy
@@ -27,30 +27,27 @@ package org.jenkinsci.plugins.pipeline.modeldefinition.agent.impl
 
 
 import org.jenkinsci.plugins.pipeline.modeldefinition.agent.CheckoutScript
-import org.jenkinsci.plugins.pipeline.modeldefinition.agent.DeclarativeAgentScript
+import org.jenkinsci.plugins.pipeline.modeldefinition.agent.DeclarativeAgentScript2
 import org.jenkinsci.plugins.workflow.cps.CpsScript
 
-class LabelScript extends DeclarativeAgentScript<Label> {
+class LabelScript extends DeclarativeAgentScript2<Label> {
 
     LabelScript(CpsScript s, Label a) {
         super(s, a)
     }
 
     @Override
-    Closure run(Closure body) {
-        Closure run = {
-            script.node(describable?.label) {
-                CheckoutScript.doCheckout(script, describable, describable.customWorkspace, body).call()
-            }
-        }
+    void run(Closure body) {
         if (describable.retries > 1) {
-            return {
-                script.retry(count: describable.retries, conditions: [script.agent(), script.nonresumable()]) {
-                    run.call()
+            script.retry(count: describable.retries, conditions: [script.agent(), script.nonresumable()]) {
+                script.node(describable?.label) {
+                    CheckoutScript.doCheckout2(script, describable, describable.customWorkspace, body)
                 }
             }
         } else {
-            run
+            script.node(describable?.label) {
+                CheckoutScript.doCheckout2(script, describable, describable.customWorkspace, body)
+            }
         }
     }
 }
\ No newline at end of file
diff --git a/pipeline-model-definition/src/main/resources/org/jenkinsci/plugins/pipeline/modeldefinition/agent/impl/NoneScript.groovy b/pipeline-model-definition/src/main/resources/org/jenkinsci/plugins/pipeline/modeldefinition/agent/impl/NoneScript.groovy
index 426877b73..92e791897 100644
--- a/pipeline-model-definition/src/main/resources/org/jenkinsci/plugins/pipeline/modeldefinition/agent/impl/NoneScript.groovy
+++ b/pipeline-model-definition/src/main/resources/org/jenkinsci/plugins/pipeline/modeldefinition/agent/impl/NoneScript.groovy
@@ -25,17 +25,17 @@
 
 package org.jenkinsci.plugins.pipeline.modeldefinition.agent.impl
 
-import org.jenkinsci.plugins.pipeline.modeldefinition.agent.DeclarativeAgentScript
+import org.jenkinsci.plugins.pipeline.modeldefinition.agent.DeclarativeAgentScript2
 import org.jenkinsci.plugins.workflow.cps.CpsScript
 
-class NoneScript extends DeclarativeAgentScript<None> {
+class NoneScript extends DeclarativeAgentScript2<None> {
 
     NoneScript(CpsScript s, None a) {
         super(s, a)
     }
 
     @Override
-    Closure run(Closure body) {
-        return body
+    void run(Closure body) {
+        body.call()
     }
 }
\ No newline at end of file
diff --git a/pipeline-model-definition/src/test/java/org/jenkinsci/plugins/pipeline/modeldefinition/BasicModelDefTest.java b/pipeline-model-definition/src/test/java/org/jenkinsci/plugins/pipeline/modeldefinition/BasicModelDefTest.java
index f05e0ceac..a1b26de42 100644
--- a/pipeline-model-definition/src/test/java/org/jenkinsci/plugins/pipeline/modeldefinition/BasicModelDefTest.java
+++ b/pipeline-model-definition/src/test/java/org/jenkinsci/plugins/pipeline/modeldefinition/BasicModelDefTest.java
@@ -78,7 +78,7 @@ public static void setUpAgent() throws Exception {
 
     @Issue("JENKINS-47363")
     // Give this a longer timeout
-    @Test(timeout=5 * 60 * 1000)
+    @Test(timeout=10 * 60 * 1000)
     public void stages300() throws Exception {
         assumeFalse("can exceed even 5m timeout", Functions.isWindows());
         RuntimeASTTransformer.SCRIPT_SPLITTING_TRANSFORMATION = true;
diff --git a/pipeline-model-definition/src/test/resources/org/jenkinsci/plugins/pipeline/modeldefinition/agent/impl/LabelAndOtherFieldAgentScript.groovy b/pipeline-model-definition/src/test/resources/org/jenkinsci/plugins/pipeline/modeldefinition/agent/impl/LabelAndOtherFieldAgentScript.groovy
index 31d6eb8a8..7bdd6f8b9 100644
--- a/pipeline-model-definition/src/test/resources/org/jenkinsci/plugins/pipeline/modeldefinition/agent/impl/LabelAndOtherFieldAgentScript.groovy
+++ b/pipeline-model-definition/src/test/resources/org/jenkinsci/plugins/pipeline/modeldefinition/agent/impl/LabelAndOtherFieldAgentScript.groovy
@@ -25,25 +25,23 @@
 
 package org.jenkinsci.plugins.pipeline.modeldefinition.agent.impl
 
-import org.jenkinsci.plugins.pipeline.modeldefinition.agent.DeclarativeAgentScript
+import org.jenkinsci.plugins.pipeline.modeldefinition.agent.DeclarativeAgentScript2
 import org.jenkinsci.plugins.workflow.cps.CpsScript
 
-class LabelAndOtherFieldAgentScript extends DeclarativeAgentScript<LabelAndOtherFieldAgent> {
+class LabelAndOtherFieldAgentScript extends DeclarativeAgentScript2<LabelAndOtherFieldAgent> {
 
     LabelAndOtherFieldAgentScript(CpsScript s, LabelAndOtherFieldAgent a) {
         super(s, a)
     }
 
     @Override
-    Closure run(Closure body) {
+    void run(Closure body) {
         script.echo "Running in labelAndOtherField with otherField = ${describable.getOtherField()}"
         script.echo "And nested: ${describable.getNested()}"
         Label l = (Label) Label.DescriptorImpl.instanceForName("label", [label: describable.label])
         l.inStage = describable.inStage
         l.doCheckout = describable.doCheckout
         LabelScript labelScript = (LabelScript) l.getScript(script)
-        return labelScript.run {
-            body.call()
-        }
+        labelScript.run(body)
     }
 }
\ No newline at end of file
diff --git a/pipeline-model-extensions/src/main/java/org/jenkinsci/plugins/pipeline/modeldefinition/agent/DeclarativeAgent.java b/pipeline-model-extensions/src/main/java/org/jenkinsci/plugins/pipeline/modeldefinition/agent/DeclarativeAgent.java
index e5b3d57cc..62bc1a0c1 100644
--- a/pipeline-model-extensions/src/main/java/org/jenkinsci/plugins/pipeline/modeldefinition/agent/DeclarativeAgent.java
+++ b/pipeline-model-extensions/src/main/java/org/jenkinsci/plugins/pipeline/modeldefinition/agent/DeclarativeAgent.java
@@ -28,6 +28,7 @@
 import java.util.Map;
 import edu.umd.cs.findbugs.annotations.NonNull;
 import hudson.Extension;
+import java.util.logging.Logger;
 import org.jenkinsci.plugins.pipeline.modeldefinition.options.DeclarativeOption;
 import org.jenkinsci.plugins.pipeline.modeldefinition.withscript.WithScriptDescribable;
 import org.jenkinsci.plugins.pipeline.modeldefinition.withscript.WithScriptScript;
@@ -41,6 +42,9 @@
  * @author Andrew Bayer
  */
 public abstract class DeclarativeAgent<A extends DeclarativeAgent<A>> extends WithScriptDescribable<A> implements ExtensionPoint {
+
+    private static final Logger LOGGER = Logger.getLogger(DeclarativeAgent.class.getName());
+
     protected boolean inStage;
     protected boolean doCheckout;
     protected String subdirectory;
@@ -53,7 +57,11 @@ public WithScriptScript getScript(CpsScript cpsScript) throws Exception {
 
         cpsScript.getClass().getClassLoader().loadClass("org.jenkinsci.plugins.pipeline.modeldefinition.agent.CheckoutScript");
 
-        return super.getScript(cpsScript);
+        var script = super.getScript(cpsScript);
+        if (script instanceof DeclarativeAgentScript) {
+            LOGGER.warning(() -> script.getClass().getName() + " should implement " + DeclarativeAgentScript2.class.getName());
+        }
+        return script;
     }
 
     public void setInStage(boolean inStage) {
diff --git a/pipeline-model-extensions/src/main/java/org/jenkinsci/plugins/pipeline/modeldefinition/agent/DeclarativeAgentScript.java b/pipeline-model-extensions/src/main/java/org/jenkinsci/plugins/pipeline/modeldefinition/agent/DeclarativeAgentScript.java
index 4b0140168..e959a7925 100644
--- a/pipeline-model-extensions/src/main/java/org/jenkinsci/plugins/pipeline/modeldefinition/agent/DeclarativeAgentScript.java
+++ b/pipeline-model-extensions/src/main/java/org/jenkinsci/plugins/pipeline/modeldefinition/agent/DeclarativeAgentScript.java
@@ -27,7 +27,7 @@
 import org.jenkinsci.plugins.pipeline.modeldefinition.withscript.WithScriptScript;
 import org.jenkinsci.plugins.workflow.cps.CpsScript;
 
-
+@Deprecated
 public abstract class DeclarativeAgentScript<A extends DeclarativeAgent<A>> extends WithScriptScript<A> {
 
     public DeclarativeAgentScript(CpsScript s, A a) {
diff --git a/pipeline-model-extensions/src/main/java/org/jenkinsci/plugins/pipeline/modeldefinition/agent/DeclarativeAgentScript2.java b/pipeline-model-extensions/src/main/java/org/jenkinsci/plugins/pipeline/modeldefinition/agent/DeclarativeAgentScript2.java
new file mode 100644
index 000000000..3d64863b9
--- /dev/null
+++ b/pipeline-model-extensions/src/main/java/org/jenkinsci/plugins/pipeline/modeldefinition/agent/DeclarativeAgentScript2.java
@@ -0,0 +1,38 @@
+/*
+ * The MIT License
+ *
+ * Copyright (c) 2016, CloudBees, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+
+package org.jenkinsci.plugins.pipeline.modeldefinition.agent;
+
+import groovy.lang.Closure;
+import org.jenkinsci.plugins.pipeline.modeldefinition.withscript.WithScriptScript;
+import org.jenkinsci.plugins.workflow.cps.CpsScript;
+
+public abstract class DeclarativeAgentScript2<A extends DeclarativeAgent<A>> extends WithScriptScript<A> {
+
+    public DeclarativeAgentScript2(CpsScript s, A a) {
+        super(s, a);
+    }
+
+    public abstract void run(Closure body);
+}
diff --git a/pipeline-model-extensions/src/main/java/org/jenkinsci/plugins/pipeline/modeldefinition/agent/RetryableDeclarativeAgent.java b/pipeline-model-extensions/src/main/java/org/jenkinsci/plugins/pipeline/modeldefinition/agent/RetryableDeclarativeAgent.java
index 6069e99cc..4e367dce3 100644
--- a/pipeline-model-extensions/src/main/java/org/jenkinsci/plugins/pipeline/modeldefinition/agent/RetryableDeclarativeAgent.java
+++ b/pipeline-model-extensions/src/main/java/org/jenkinsci/plugins/pipeline/modeldefinition/agent/RetryableDeclarativeAgent.java
@@ -28,21 +28,18 @@
 
 /**
  * A type of {@code agent} option that supports automatic retries.
- * Usage from your {@link DeclarativeAgentScript#run} would look something like:
+ * Usage from your {@link DeclarativeAgentScript2#run} would look something like:
  * <pre>{@code
- * Closure run = {
- *     script.node {
- *         CheckoutScript.doCheckout(script, describable, null, body).call()
- *     }
- * }
  * if (describable.retries > 1) {
- *     return {
- *         script.retry(count: describable.retries, conditions: [script.agent(), script.nonresumable()]) {
- *             run.call()
+ *     script.retry(count: describable.retries, conditions: [script.agent(), script.nonresumable()]) {
+ *         script.node {
+ *             CheckoutScript.doCheckout2(script, describable, null, body)
  *         }
  *     }
  * } else {
- *     run
+ *     script.node {
+ *         CheckoutScript.doCheckout2(script, describable, null, body)
+ *     }
  * }}</pre>
  */
 public abstract class RetryableDeclarativeAgent<A extends RetryableDeclarativeAgent<A>> extends DeclarativeAgent<A> {
diff --git a/pipeline-model-extensions/src/main/resources/org/jenkinsci/plugins/pipeline/modeldefinition/agent/CheckoutScript.groovy b/pipeline-model-extensions/src/main/resources/org/jenkinsci/plugins/pipeline/modeldefinition/agent/CheckoutScript.groovy
index 8c0d5de63..30a2d7f7e 100644
--- a/pipeline-model-extensions/src/main/resources/org/jenkinsci/plugins/pipeline/modeldefinition/agent/CheckoutScript.groovy
+++ b/pipeline-model-extensions/src/main/resources/org/jenkinsci/plugins/pipeline/modeldefinition/agent/CheckoutScript.groovy
@@ -30,40 +30,41 @@ import org.jenkinsci.plugins.workflow.cps.CpsScript
 
 class CheckoutScript implements Serializable {
     
+    @Deprecated
     static Closure doCheckout(CpsScript script, DeclarativeAgent agent, String customWorkspace = null, Closure body) {
         return {
-            if (customWorkspace) {
-                script.ws(customWorkspace) {
-                    checkoutAndRun(script, agent, body).call()
-                }
-            } else {
-                checkoutAndRun(script, agent, body).call()
+            doCheckout2(script, agent, customWorkspace, body)
+        }
+    }
+
+    static void doCheckout2(CpsScript script, DeclarativeAgent agent, String customWorkspace = null, Closure body) {
+        if (customWorkspace) {
+            script.ws(customWorkspace) {
+                checkoutAndRun(script, agent, body)
             }
+        } else {
+            checkoutAndRun(script, agent, body)
         }
     }
-    
-    private static Closure checkoutAndRun(CpsScript script, DeclarativeAgent agent, Closure body) {
-        return {
-            def checkoutMap = [:]
 
-            if (agent.isDoCheckout() && agent.hasScmContext(script)) {
-                String subDir = agent.subdirectory
-                if (subDir != null && subDir != "") {
-                    script.dir(subDir) {
-                        checkoutMap.putAll(performCheckout(script, agent))
-                    }
-                } else {
+    private static void checkoutAndRun(CpsScript script, DeclarativeAgent agent, Closure body) {
+        def checkoutMap = [:]
+
+        if (agent.isDoCheckout() && agent.hasScmContext(script)) {
+            String subDir = agent.subdirectory
+            if (subDir != null && subDir != "") {
+                script.dir(subDir) {
                     checkoutMap.putAll(performCheckout(script, agent))
                 }
-            }
-            if (checkoutMap) {
-                script.withEnv(checkoutMap.collect { k, v -> "${k}=${v}" }) {
-                    body.call()
-                }
             } else {
-                body.call()
+                checkoutMap.putAll(performCheckout(script, agent))
             }
         }
+        if (checkoutMap) {
+            script.withEnv(checkoutMap.collect { k, v -> "${k}=${v}" }, body)
+        } else {
+            body.call()
+        }
     }
 
     private static Map performCheckout(CpsScript script, DeclarativeAgent agent) {